momo-ai 1.0.3 → 1.0.4

package/package.json

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

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

@@ -35,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

@@ -72,9 +72,22 @@ const _isRequirementExists = (changesDir, requirementName) => {
  */
 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('✅ 计划提示词已复制到剪贴板');
@@ -94,9 +107,12 @@ const _copyToClipboard = async (content, requirementName) => {
         Ec.waiting(`📄 计划提示词已保存到文件: ${filePath}`);
     } catch (error) {
         Ec.waiting(`复制到剪贴板失败: ${error.message}`);
-        // 在非 macOS 系统上可能没有 pbcopy，提供备选方案
+        // 提供备选方案
         Ec.waiting('计划提示词内容:');
         console.log(content);
+        if (process.platform === 'win32') {
+            Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
+        }
     }
 };
 
@@ -119,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 {
@@ -144,6 +169,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/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

@@ -63,7 +63,19 @@ const _renderTemplate = (template, data) => {
  */
 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();
 
@@ -73,7 +85,7 @@ const _copyToClipboard = async (content, requirementName, taskName) => {
                 if (code === 0) {
                     resolve();
                 } else {
-                    reject(new Error(`pbcopy 进程退出码: ${code}`));
+                    reject(new Error(`剪贴板进程退出码: ${code}`));
                 }
             });
             proc.on('error', reject);
@@ -99,6 +111,9 @@ const _copyToClipboard = async (content, requirementName, taskName) => {
         // 备选方案：显示内容
         Ec.waiting('提示词内容:');
         console.log(content);
+        if (process.platform === 'win32') {
+            Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
+        }
     }
 };
 

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 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
+        }
     }
 };