momo-ai 1.0.2 → 1.0.4

package/README.md

@@ -8,22 +8,21 @@
 当前工具会在操作系统中安装 `momo` 命令，使用它进行 `SDD - Spec Driven Development` 开发：
 
 1. 参考：`OpenSpec / Spec-Kit / Kiro`
-2. 工具：`TRAE` 工具集成（推荐使用国际版）/ `Cursor`（推荐使用，可实现多个Agent开发）
-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` 的模板化。
+完整生命周期的整体开发流程，是 SDD 的一种落地手段——暴力、简单、易懂。由于辅助工具可选择模型，所以本工具不提供模型选择，模型本身取决于你所使用的工具本身，命令行只是一个辅助，核心开发模式为：
+`AI 开发 + 人工审核`，本工具的核心是 `prompt` 的模板化。
 
-> 多个异构Agent！中文优先！
+> 除开 `momo` 命令后续会提供和模型直接交互的 `lain` 命令，近似 `iFlow / openspec` 的功能。
 
-## 2. 使用
-
-- 执行 `momo repo` 的过程中会依赖一个已经初始化好的项目 `Git` 地址，且当前项目本身依赖一个 `Git`（因为项目是以
-  `submodule` 的方式添加到环境中的）。
-- 移除相关命令如 `submodule` 只支持 Linux/Mac 的脚本，这个用独立脚本防止更改丢失。
+## 2. 工具使用
 
 ### 2.1. 安装
 
@@ -33,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. 命令：不定模型
 
@@ -86,30 +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帮助拆分和书写）
-4. 使用 `momo add -n 需求名称` 添加细节需求（可用AI帮助拆分和书写：`momo plan -n 需求名称`）
-5. 使用 `momo tasks` 列出所有任务，并且使用 `momo run` 运行任务得到任务提示词
-
-> 带 (CV) 标记的命令运行成功后可直接“Ctrl + V”粘贴到 TRAE / Lingma / Cursor / Kiro 中执行。
+> 控制台开发中（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.2",
+    "version": "1.0.4",
     "description": "Rachel Momo ( OpenSpec )",
     "main": "src/momo.js",
     "bin": {

package/src/commander/run.json

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

package/src/epic/momo.fn.out.js

@@ -22,15 +22,16 @@ const outString = (paths, content, sync = false) => __FX.fxContinue(!!content, (
 const outCopy = (data) => new Promise(function (resolve, reject) {
     const platform = os.platform();
     let cmd = '';
-    if (os.platform() === 'win32') {
+    if (platform === 'win32') {
         cmd = 'clip';
-    } else if (os.platform() === 'darwin') {
+    } else if (platform === 'darwin') {
         cmd = 'pbcopy';
     } else {
-        __FX.fxError(10032, platform);
+        // 对于Linux和其他Unix-like系统，尝试使用xclip
+        cmd = 'xclip';
     }
 
-    const proc = require('child_process').spawn(cmd);
+    const proc = require('child_process').spawn(cmd, platform !== 'win32' && platform !== 'darwin' ? ['-selection', 'clipboard'] : []);
     proc.on('error', function (err) {
         reject(err);
     });

package/src/executor/executeActor.js

@@ -49,65 +49,85 @@ const _selectLLM = async (actorName) => {
     };
 };
 
-module.exports = (options) => {
+module.exports = async (options) => {
     // 参数提取
     const parsed = Ec.parseArgument(options);
+    const actorName = parsed.actor || parsed.a;
 
-    const actorName = parsed.name;
-    Ec.waiting(`🔍 准备创建角色: ${actorName}`);
-
-    // 创建角色目录
-    const actorDir = path.resolve(process.cwd(), 'specification', 'actor', actorName);
-    if (!fs.existsSync(actorDir)) {
-        Ec.waiting(`📁 创建角色目录: ${actorDir}`);
-        fs.mkdirSync(actorDir, {recursive: true});
-    } else {
-        Ec.waiting(`✅ 角色目录已存在: ${actorDir}`);
+    if (!actorName) {
+        Ec.error("❌ 请提供角色名称 (-a, --actor)");
+        process.exit(1);
+    }
+    
+    // 在 Windows 上检查非法字符
+    if (process.platform === 'win32') {
+        const illegalChars = /[<>:"/\\|?*\x00-\x1F]/g;
+        if (illegalChars.test(actorName)) {
+            Ec.error(`❌ 角色名称 "${actorName}" 包含非法字符，请避免使用以下字符: < > : " / \\ | ? * 以及控制字符`);
+            process.exit(1);
+        }
     }
 
-    // 从模板复制内容到stack.md和limit.md
-    const templatePath = path.resolve(__dirname, '../_template/LAIN/.momo/advanced/actor.md');
-    if (fs.existsSync(templatePath)) {
-        const templateContent = fs.readFileSync(templatePath, 'utf8');
-
-        // 提取技能说明部分作为stack.md的内容
-        const stackMatch = templateContent.match(/## 技能说明\s*([\s\S]*?)\s*## 角色限制/);
-        if (stackMatch && stackMatch[1]) {
-            const stackContent = `# 技术栈信息\n\n${stackMatch[1].trim()}\n`;
-            const stackPath = path.resolve(actorDir, 'stack.md');
-            fs.writeFileSync(stackPath, stackContent);
-            Ec.waiting(`📄 创建技术栈文件: ${stackPath}`);
+    try {
+        // 检查 specification/actor 目录是否存在
+        const actorBaseDir = path.resolve(process.cwd(), 'specification', 'actor');
+        if (!fs.existsSync(actorBaseDir)) {
+            Ec.error("❌ 未找到 specification/actor 目录，请先初始化项目");
+            process.exit(1);
         }
 
-        // 提取角色限制部分作为limit.md的内容
-        const limitMatch = templateContent.match(/## 角色限制\s*([\s\S]*)/);
-        if (limitMatch && limitMatch[1]) {
-            const limitContent = `# 角色限制\n\n${limitMatch[1].trim()}\n`;
-            const limitPath = path.resolve(actorDir, 'limit.md');
-            fs.writeFileSync(limitPath, limitContent);
-            Ec.waiting(`📄 创建限制文件: ${limitPath}`);
+        // 检查角色是否已存在
+        const actorDir = path.resolve(actorBaseDir, actorName);
+        if (fs.existsSync(actorDir)) {
+            Ec.error(`❌ 角色 "${actorName}" 已存在`);
+            process.exit(1);
         }
-    }
 
-    // 交互式选择LLM
-    _selectLLM(actorName)
-        .then((llmConfig) => {
-            // 创建config.json文件
-            const configPath = path.resolve(actorDir, 'config.json');
-            fs.writeFileSync(configPath, JSON.stringify(llmConfig, null, 4));
-            Ec.waiting(`⚙️  创建配置文件: ${configPath}`);
+        // 创建角色目录
+        if (!fs.existsSync(actorDir)) {
+            fs.mkdirSync(actorDir, { recursive: true });
+        }
 
-            Ec.info(`✅ 角色 "${actorName}" 创建完成`);
-            // 关闭 readline 接口
-            Ec.askClose();
-            // 退出程序
-            process.exit(0);
-        })
-        .catch((error) => {
-            Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
-            // 关闭 readline 接口
-            Ec.askClose();
-            // 退出程序
+        // 从模板复制内容到stack.md和limit.md
+        const templatePath = path.resolve(__dirname, '../_template/LAIN/.momo/advanced/actor.md');
+        if (fs.existsSync(templatePath)) {
+            const templateContent = fs.readFileSync(templatePath, 'utf8');
+            
+            // 提取技术栈和限制信息
+            const stackMatch = templateContent.match(/## 技术栈([\s\S]*?)## 限制/);
+            const limitMatch = templateContent.match(/## 限制([\s\S]*)/);
+            
+            if (stackMatch && limitMatch) {
+                const stackContent = `# 技术栈信息\n\n${stackMatch[1].trim()}\n`;
+                const stackPath = path.resolve(actorDir, 'stack.md');
+                fs.writeFileSync(stackPath, stackContent);
+                Ec.waiting(`📄 创建技术栈文件: ${stackPath}`);
+                
+                const limitContent = `# 角色限制\n\n${limitMatch[1].trim()}\n`;
+                const limitPath = path.resolve(actorDir, 'limit.md');
+                fs.writeFileSync(limitPath, limitContent);
+                Ec.waiting(`📄 创建限制文件: ${limitPath}`);
+                
+                // 创建config.json文件
+                const configPath = path.resolve(actorDir, 'config.json');
+                fs.writeFileSync(configPath, JSON.stringify(llmConfig, null, 4));
+                Ec.waiting(`📄 创建配置文件: ${configPath}`);
+                
+                Ec.info(`✅ 成功添加新角色 "${actorName}"`);
+                process.exit(0);
+            } else {
+                Ec.error("❌ 模板文件格式不正确");
+                process.exit(1);
+            }
+        } else {
+            Ec.error(`❌ 未找到模板文件: ${templatePath}`);
             process.exit(1);
-        });
-};
+        }
+    } catch (error) {
+        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        if (process.platform === 'win32') {
+            Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
+        }
+        process.exit(1);
+    }
+};

package/src/executor/executeAdd.js

@@ -34,6 +34,9 @@ const _readTemplate = async (templatePath) => {
         return content;
     } catch (error) {
         Ec.waiting(`读取模板文件失败: ${error.message}`);
+        if (process.platform === 'win32') {
+            Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
+        }
         throw error;
     }
 };
@@ -117,6 +120,10 @@ const _copyTemplateFiles = async (templateDir, targetDir, sourceFilePath = null)
         } else if (fs.existsSync(proposalSource)) {
             Ec.waiting(`拷贝文件: ${proposalTarget}`);
             await fsAsync.copyFile(proposalSource, proposalTarget);
+        } else {
+            // 如果模板文件不存在，则创建空文件
+            Ec.waiting(`创建空文件: ${proposalTarget}`);
+            await fsAsync.writeFile(proposalTarget, '');
         }
         
         // 拷贝 tasks.md
@@ -125,6 +132,10 @@ const _copyTemplateFiles = async (templateDir, targetDir, sourceFilePath = null)
         if (fs.existsSync(tasksSource)) {
             Ec.waiting(`拷贝文件: ${tasksTarget}`);
             await fsAsync.copyFile(tasksSource, tasksTarget);
+        } else {
+            // 如果模板文件不存在，则创建空文件
+            Ec.waiting(`创建空文件: ${tasksTarget}`);
+            await fsAsync.writeFile(tasksTarget, '');
         }
         
         // 创建 tasks 目录
@@ -140,9 +151,16 @@ const _copyTemplateFiles = async (templateDir, targetDir, sourceFilePath = null)
         if (fs.existsSync(taskDetailSource)) {
             Ec.waiting(`拷贝文件: ${taskDetailTarget}`);
             await fsAsync.copyFile(taskDetailSource, taskDetailTarget);
+        } else {
+            // 如果模板文件不存在，则创建空文件
+            Ec.waiting(`创建空文件: ${taskDetailTarget}`);
+            await fsAsync.writeFile(taskDetailTarget, '');
         }
     } catch (error) {
         Ec.waiting(`拷贝模板文件失败: ${error.message}`);
+        if (process.platform === 'win32') {
+            Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
+        }
         throw error;
     }
 };
@@ -155,13 +173,26 @@ const _copyToClipboard = async (content) => {
     try {
         // 去除换行符，将内容合并为一行
         const contentWithoutNewlines = content.replace(/\r?\n|\r/g, ' ');
-        const proc = spawn('pbcopy', { stdio: 'pipe' });
+        
+        // 根据操作系统选择合适的剪贴板命令
+        let proc;
+        if (process.platform === 'darwin') {
+            // macOS
+            proc = spawn('pbcopy', { stdio: 'pipe' });
+        } else if (process.platform === 'win32') {
+            // Windows
+            proc = spawn('clip', { stdio: 'pipe' });
+        } else {
+            // Linux/其他系统，尝试使用xclip
+            proc = spawn('xclip', ['-selection', 'clipboard'], { stdio: 'pipe' });
+        }
+        
         proc.stdin.write(contentWithoutNewlines);
         proc.stdin.end();
         Ec.waiting('✅ 提示词已复制到剪贴板');
     } catch (error) {
         Ec.waiting(`复制到剪贴板失败: ${error.message}`);
-        // 在非 macOS 系统上可能没有 pbcopy，提供备选方案
+        // 提供备选方案
         Ec.waiting('提示词内容:');
         console.log(content);
     }
@@ -203,6 +234,15 @@ module.exports = async (options) => {
         requirementName = await _extractTitleFromMarkdown(sourceFilePath);
     }
     
+    // 检查需求名称是否包含非法字符（Windows 上特别检查）
+    if (process.platform === 'win32') {
+        const illegalChars = /[<>:"/\\|?*\x00-\x1F]/g;
+        if (illegalChars.test(requirementName)) {
+            Ec.error(`❌ 需求名称 "${requirementName}" 包含非法字符，请避免使用以下字符: < > : " / \\ | ? * 以及控制字符`);
+            process.exit(1);
+        }
+    }
+    
     // 检查需求名称是否包含点号（除了允许的独立需求）
     if (!hasExtension && requirementName.includes('.')) {
         Ec.error("❌ 独立需求名称不能包含点号(.)，以防止与文件扩展名混淆");
@@ -224,10 +264,36 @@ module.exports = async (options) => {
             process.exit(1);
         }
         
+        // 确保 changes 目录存在
+        if (!fs.existsSync(changesDir)) {
+            Ec.waiting(`创建目录: ${changesDir}`);
+            try {
+                await fsAsync.mkdir(changesDir, { recursive: true });
+            } catch (mkdirError) {
+                Ec.error(`❌ 创建目录失败: ${mkdirError.message}`);
+                if (process.platform === 'win32') {
+                    Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
+                }
+                process.exit(1);
+            }
+        }
+        
         // 创建需求目录
         const requirementDir = path.join(changesDir, requirementName);
         Ec.waiting(`创建需求目录: ${requirementDir}`);
-        await fsAsync.mkdir(requirementDir, { recursive: true });
+        try {
+            await fsAsync.mkdir(requirementDir, { recursive: true });
+        } catch (mkdirError) {
+            Ec.error(`❌ 创建目录失败: ${mkdirError.message}`);
+            if (process.platform === 'win32') {
+                Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
+                // 检查是否是由于特殊字符导致的问题
+                if (mkdirError.message.includes('Invalid argument') || mkdirError.message.includes('EINVAL')) {
+                    Ec.waiting('💡 可能是由于需求名称包含非法字符，请尝试使用更简单的名称');
+                }
+            }
+            process.exit(1);
+        }
         
         // 拷贝模板文件
         await _copyTemplateFiles(templateDir, requirementDir, sourceFilePath);
@@ -243,6 +309,9 @@ module.exports = async (options) => {
         process.exit(0);
     } catch (error) {
         Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        if (process.platform === 'win32') {
+            Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
+        }
         process.exit(1);
     }
 };

package/src/executor/executeEnv.js

@@ -22,22 +22,18 @@ const _getVersion = () => {
 };
 
 /**
- * 检查命令是否存在
+ * 检查命令是否可用
  * @param {string} command 命令名称
- * @returns {Promise<boolean>} 命令是否存在
+ * @returns {Promise<boolean>} 命令是否可用
  */
-const _checkCommand = async (command) => {
+const _isCommandAvailable = async (command) => {
     try {
-        await execAsync(`which ${command}`);
+        // 在 Windows 上使用 where 命令，在其他系统上使用 which 命令
+        const whereCmd = process.platform === 'win32' ? 'where' : 'which';
+        await execAsync(`${whereCmd} ${command}`);
         return true;
     } catch (error) {
-        try {
-            // 在 Windows 上尝试 where 命令
-            await execAsync(`where ${command}`);
-            return true;
-        } catch (winError) {
-            return false;
-        }
+        return false;
     }
 };
 
@@ -71,7 +67,7 @@ module.exports = async () => {
 
     // 检查每个命令
     for (const command of requiredCommands) {
-        const isAvailable = await _checkCommand(command);
+        const isAvailable = await _isCommandAvailable(command);
 
         if (isAvailable) {
             // const version = await _getCommandVersion(command);

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/"
     ];
 
     // 创建所有目录
@@ -34,8 +35,15 @@ const _ioDirectory = async (baseDir) => {
     for (const folder of folders) {
         Ec.waiting("创建目录：" + folder);
         const directory = path.resolve(baseDir, folder);
-        await fsAsync.mkdir(directory, {recursive: true});
-        results.push(true);
+        try {
+            await fsAsync.mkdir(directory, {recursive: true});
+            results.push(true);
+        } catch (error) {
+            if (process.platform === 'win32') {
+                Ec.waiting(`💡 Windows 用户提示: 创建目录失败，可能是由于权限不足或路径包含非法字符`);
+            }
+            throw error;
+        }
     }
     return results;
 }

package/src/executor/executeOpen.js

@@ -96,6 +96,9 @@ module.exports = async (options) => {
         
     } catch (error) {
         Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        if (process.platform === 'win32') {
+            Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
+        }
         Ec.askClose();
         process.exit(1);
     }
@@ -108,7 +111,9 @@ module.exports = async (options) => {
  */
 const _isCommandAvailable = async (command) => {
     return new Promise((resolve) => {
-        const process = spawn('which', [command]);
+        // 在 Windows 上使用 where 命令，在其他系统上使用 which 命令
+        const whereCmd = process.platform === 'win32' ? 'where' : 'which';
+        const process = spawn(whereCmd, [command]);
         process.on('close', (code) => {
             resolve(code === 0);
         });
@@ -140,6 +145,9 @@ const _openWithTool = async (tool) => {
         child.on('error', (error) => {
             if (error.code === 'ENOENT') {
                 Ec.error(`❌ 未找到命令: ${tool}，请确保已正确安装`);
+                if (process.platform === 'win32') {
+                    Ec.waiting('💡 Windows 用户提示: 请确保工具已正确安装并在 PATH 环境变量中');
+                }
                 reject(new Error(`未找到命令: ${tool}，请确保已正确安装`));
             } else {
                 Ec.error(`❌ 执行 ${tool} 时发生错误: ${error.message}`);

package/src/executor/executePlan.js

@@ -68,20 +68,51 @@ 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, ' ');
-        const proc = spawn('pbcopy', { stdio: 'pipe' });
+        
+        // 根据操作系统选择合适的剪贴板命令
+        let proc;
+        if (process.platform === 'darwin') {
+            // macOS
+            proc = spawn('pbcopy', { stdio: 'pipe' });
+        } else if (process.platform === 'win32') {
+            // Windows
+            proc = spawn('clip', { stdio: 'pipe' });
+        } else {
+            // Linux/其他系统，尝试使用xclip
+            proc = spawn('xclip', ['-selection', 'clipboard'], { stdio: 'pipe' });
+        }
+        
         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，提供备选方案
+        // 提供备选方案
         Ec.waiting('计划提示词内容:');
         console.log(content);
+        if (process.platform === 'win32') {
+            Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
+        }
     }
 };
 
@@ -104,6 +135,15 @@ module.exports = async (options) => {
         process.exit(1);
     }
     
+    // 在 Windows 上检查非法字符
+    if (process.platform === 'win32') {
+        const illegalChars = /[<>:"/\\|?*\x00-\x1F]/g;
+        if (illegalChars.test(requirementName)) {
+            Ec.error(`❌ 需求名称 "${requirementName}" 包含非法字符，请避免使用以下字符: < > : " / \\ | ? * 以及控制字符`);
+            process.exit(1);
+        }
+    }
+    
     Ec.waiting(`准备生成需求计划: ${requirementName}`);
     
     try {
@@ -123,12 +163,15 @@ module.exports = async (options) => {
         const renderedContent = _renderTemplate(templateContent, { NAME: requirementName });
         
         // 将提示词复制到剪贴板
-        await _copyToClipboard(renderedContent);
+        await _copyToClipboard(renderedContent, requirementName);
         
         Ec.info(`✅ 成功生成需求 "${requirementName}" 的计划提示词`);
         process.exit(0);
     } catch (error) {
         Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        if (process.platform === 'win32') {
+            Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
+        }
         process.exit(1);
     }
 };

package/src/executor/executeRepo.js

@@ -26,11 +26,15 @@ const _isGitRepo = async () => {
 const _initGitRepo = async () => {
     try {
         Ec.waiting('正在初始化 Git 仓库');
-        const command = 'git init -b master';
+        // 在 Windows 上使用不同的命令格式
+        const command = process.platform === 'win32' ? 'git init' : 'git init -b master';
         await execAsync(command);
         Ec.waiting('✅ 成功初始化 Git 仓库');
     } catch (error) {
         Ec.error(`❌ 初始化 Git 仓库失败: ${error.message}`);
+        if (process.platform === 'win32') {
+            Ec.waiting('💡 Windows 用户提示: 请确保已安装 Git 并在 PATH 环境变量中');
+        }
         throw error;
     }
 };

package/src/executor/executeRun.js

@@ -58,10 +58,24 @@ 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'});
+        // 根据操作系统选择合适的剪贴板命令
+        let proc;
+        if (process.platform === 'darwin') {
+            // macOS
+            proc = spawn('pbcopy', {stdio: 'pipe'});
+        } else if (process.platform === 'win32') {
+            // Windows
+            proc = spawn('clip', {stdio: 'pipe'});
+        } else {
+            // Linux/其他系统，尝试使用xclip
+            proc = spawn('xclip', ['-selection', 'clipboard'], {stdio: 'pipe'});
+        }
+        
         proc.stdin.write(content);
         proc.stdin.end();
 
@@ -71,18 +85,35 @@ const _copyToClipboard = async (content) => {
                 if (code === 0) {
                     resolve();
                 } else {
-                    reject(new Error(`pbcopy 进程退出码: ${code}`));
+                    reject(new Error(`剪贴板进程退出码: ${code}`));
                 }
             });
             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}`);
         // 备选方案：显示内容
         Ec.waiting('提示词内容:');
         console.log(content);
+        if (process.platform === 'win32') {
+            Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
+        }
     }
 };
 
@@ -507,7 +538,7 @@ module.exports = async (options) => {
                 });
 
                 // 将提示词复制到剪贴板
-                await _copyToClipboard(renderedContent);
+                await _copyToClipboard(renderedContent, requirementName, selectedTask.name);
                 Ec.info(`✅ 任务 ${selectedTask.name} 准备完成，请查看剪切板中的提示词`);
             } catch (error) {
                 Ec.info(`✅ 任务 ${selectedTask.name} 查找完成`);

package/src/executor/executeTasks.js

@@ -61,7 +61,19 @@ const _renderTemplate = (template, data) => {
  */
 const _copyToClipboard = async (content) => {
     try {
-        const proc = spawn('pbcopy', { stdio: 'pipe' });
+        // 根据操作系统选择合适的剪贴板命令
+        let proc;
+        if (process.platform === 'darwin') {
+            // macOS
+            proc = spawn('pbcopy', { stdio: 'pipe' });
+        } else if (process.platform === 'win32') {
+            // Windows
+            proc = spawn('clip', { stdio: 'pipe' });
+        } else {
+            // Linux/其他系统，尝试使用xclip
+            proc = spawn('xclip', ['-selection', 'clipboard'], { stdio: 'pipe' });
+        }
+        
         proc.stdin.write(content);
         proc.stdin.end();
         
@@ -71,7 +83,7 @@ const _copyToClipboard = async (content) => {
                 if (code === 0) {
                     resolve();
                 } else {
-                    reject(new Error(`pbcopy 进程退出码: ${code}`));
+                    reject(new Error(`剪贴板进程退出码: ${code}`));
                 }
             });
             proc.on('error', reject);
@@ -83,6 +95,9 @@ const _copyToClipboard = async (content) => {
         // 备选方案：显示内容
         Ec.waiting('提示词内容:');
         console.log(content);
+        if (process.platform === 'win32') {
+            Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
+        }
     }
 };