momo-ai 1.0.21 → 1.0.22

package/src/executor/{executeSkills.js → executeApply.js}

@@ -5,23 +5,48 @@ const Ec = require('../epic');
 const fsAsync = require('fs').promises;
 const readline = require('readline');
 const { execSync } = require('child_process');
-const { parseOptional, parseBool } = require('../utils/momo-args');
+const { parseOptional } = require('../utils/momo-args');
 const { copyDir, readJson, parseFile } = require('../utils/momo-file-utils');
+const { selectSingle } = require('../utils/momo-menu');
 
-// 全局技能仓库路径
-const GLOBAL_SKILLS_DIR = path.join(os.homedir(), '.claude', 'skills');
 // 远程仓库配置文件路径
 const REPOSITORIES_CONFIG = path.join(__dirname, '../_skill/repositories.json');
 // 本地缓存仓库目录
 const LOCAL_REPO_CACHE_DIR = '.r2mo/repo';
 
-// 来源标记
-const SOURCE_GLOBAL = 'NORM';
-const SOURCE_PROJECT = 'R2MO';
-
 // 限定技仓库地址
 const RESTRICTED_REPOSITORY = 'https://gitee.com/silentbalanceyh/r2mo-lain.git';
 
+/**
+ * 获取目标路径配置（基于当前项目目录）
+ * @returns {Array} 目标路径配置列表
+ */
+const _getTargetPaths = () => {
+    const projectDir = process.cwd();
+    return [
+        {
+            name: 'Cursor 默认',
+            description: '.claude/skills/',
+            path: path.join(projectDir, '.claude', 'skills')
+        },
+        {
+            name: 'Antigravity',
+            description: '.agent/skills/',
+            path: path.join(projectDir, '.agent', 'skills')
+        },
+        {
+            name: 'Trae CN',
+            description: '.trae/skills/',
+            path: path.join(projectDir, '.trae', 'skills')
+        },
+        {
+            name: 'Trae',
+            description: '.trae/skills/',
+            path: path.join(projectDir, '.trae', 'skills')
+        }
+    ];
+};
+
 /**
  * 确保 .r2mo/repo 在 .gitignore 中
  * @param {string} projectDir 项目目录
@@ -65,6 +90,17 @@ const _getLocalRepoPath = (projectDir, repoName) => {
     return path.join(projectDir, LOCAL_REPO_CACHE_DIR, safeName);
 };
 
+/**
+ * 检查错误是否为服务器端错误
+ * @param {Error} error 错误对象
+ * @returns {boolean} 是否为服务器错误
+ */
+const _isServerError = (error) => {
+    const errorMsg = error.message || '';
+    // 检查常见的服务器错误代码
+    return /500|502|503|504|Internal Server Error/i.test(errorMsg);
+};
+
 /**
  * 克隆或更新远程仓库到本地缓存
  * @param {string} url 仓库 URL
@@ -89,6 +125,14 @@ const _cloneOrUpdateRepository = (url, localPath) => {
             Ec.waiting('✓ 仓库已更新'.green);
             return true;
         } catch (error) {
+            // 检查是否为服务器错误
+            if (_isServerError(error)) {
+                Ec.warn('⚠️  远程服务器暂时不可用（可能是 GitHub/Gitee 服务器问题）');
+                Ec.waiting('将使用本地缓存继续操作...'.yellow);
+                // 保留现有缓存，不删除
+                return true;
+            }
+            
             Ec.warn(`更新失败，将重新克隆: ${error.message}`);
             // 删除损坏的缓存
             fs.rmSync(localPath, { recursive: true, force: true });
@@ -106,42 +150,18 @@ const _cloneOrUpdateRepository = (url, localPath) => {
         Ec.waiting('✓ 仓库克隆完成'.green);
         return true;
     } catch (error) {
+        // 检查是否为服务器错误
+        if (_isServerError(error)) {
+            Ec.error('❌ 远程服务器暂时不可用（可能是 GitHub/Gitee 服务器问题）');
+            Ec.waiting('请稍后重试，或检查网络连接');
+            return false;
+        }
+        
         Ec.error(`克隆仓库失败: ${error.message}`);
         return false;
     }
 };
 
-/**
- * 截断描述文本
- * @param {string} text 原始文本
- * @param {number} maxLen 最大长度
- * @returns {string} 截断后的文本
- */
-const _truncateDescription = (text, maxLen = 50) => {
-    if (!text) return '无描述';
-    // 移除引号
-    text = text.replace(/^["']|["']$/g, '');
-    if (text.length <= maxLen) return text;
-    return text.substring(0, maxLen - 3) + '...';
-};
-
-/**
- * 解析 -r 参数（支持无值的情况）
- * @returns {Object} { hasRemote: boolean, remoteValue: string|null }
- */
-const _parseRemoteArg = () => {
-    const result = parseOptional('remote', 'r');
-    return { hasRemote: result.hasFlag, remoteValue: result.value };
-};
-
-/**
- * 解析 -g 参数
- * @returns {boolean} 是否安装到全局目录
- */
-const _parseGlobalArg = () => {
-    return parseBool('global', 'g');
-};
-
 /**
  * 读取远程仓库配置
  * @returns {Array} 仓库列表
@@ -169,10 +189,9 @@ const _parseSkillYaml = (filePath) => {
 /**
  * 扫描技能目录
  * @param {string} skillsDir 技能目录路径
- * @param {string} source 来源标记
  * @returns {Array} 技能列表
  */
-const _scanSkillsFromDir = (skillsDir, source = '') => {
+const _scanSkillsFromDir = (skillsDir) => {
     const skills = [];
 
     if (!fs.existsSync(skillsDir)) {
@@ -204,7 +223,6 @@ const _scanSkillsFromDir = (skillsDir, source = '') => {
                         version: metadata.version || '未知',
                         category: metadata.category || '未分类',
                         tags: metadata.tags || [],
-                        source: source,
                         skillType: skillType,
                         repository: repository
                     });
@@ -217,7 +235,6 @@ const _scanSkillsFromDir = (skillsDir, source = '') => {
                         version: '未知',
                         category: '未分类',
                         tags: [],
-                        source: source,
                         skillType: '通用技',
                         repository: ''
                     });
@@ -231,9 +248,8 @@ const _scanSkillsFromDir = (skillsDir, source = '') => {
     return skills;
 };
 
-
 /**
- * 递归拷贝目录（使用工具函数）
+ * 递归拷贝目录
  * @param {string} src 源目录
  * @param {string} dest 目标目录
  */
@@ -242,107 +258,44 @@ const _copyDirectory = async (src, dest) => {
 };
 
 /**
- * 仓库选择菜单
- * @param {Array} repositories 仓库列表
- * @returns {Promise<Object|null>} 选中的仓库
+ * 截断描述文本
+ * @param {string} text 原始文本
+ * @param {number} maxLen 最大长度
+ * @returns {string} 截断后的文本
  */
-const _selectRepository = async (repositories) => {
-    return new Promise((resolve) => {
-        let cursor = 0;
-
-        const render = () => {
-            process.stdout.write('\x1B[2J\x1B[0f');
-            console.log('');
-            console.log('[Momo AI]'.blue.bold + ' ====== 选择远程仓库 ======'.blue);
-            console.log('');
-
-            repositories.forEach((repo, index) => {
-                const isActive = index === cursor;
-                const pointer = isActive ? '▸'.cyan : ' ';
-                const name = repo.name;
-                
-                if (isActive) {
-                    console.log(`  ${pointer} ${name.cyan.bold}`);
-                } else {
-                    console.log(`  ${pointer} ${name.cyan}`);
-                }
-                console.log(`       ${repo.description.gray}`);
-                console.log(`       ${repo.url.gray}`);
-            });
-
-            console.log('');
-            console.log('  ─────────────────────────────────────────────────'.gray);
-            console.log('  ↑/↓ 移动  │  回车 确认  │  q 退出'.gray);
-        };
-
-        readline.emitKeypressEvents(process.stdin);
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(true);
-        }
-
-        render();
-
-        const onKeypress = (str, key) => {
-            if (!key) return;
-
-            if (key.ctrl && key.name === 'c') {
-                process.stdin.setRawMode(false);
-                process.stdin.removeListener('keypress', onKeypress);
-                process.exit(0);
-            }
-
-            if (key.name === 'q' || key.name === 'escape') {
-                process.stdin.setRawMode(false);
-                process.stdin.removeListener('keypress', onKeypress);
-                process.stdout.write('\x1B[2J\x1B[0f');
-                resolve(null);
-                return;
-            }
-
-            if (key.name === 'up') {
-                cursor = cursor > 0 ? cursor - 1 : repositories.length - 1;
-                render();
-                return;
-            }
-
-            if (key.name === 'down') {
-                cursor = cursor < repositories.length - 1 ? cursor + 1 : 0;
-                render();
-                return;
-            }
-
-            if (key.name === 'return') {
-                process.stdin.setRawMode(false);
-                process.stdin.removeListener('keypress', onKeypress);
-                process.stdout.write('\x1B[2J\x1B[0f');
-                resolve(repositories[cursor]);
-                return;
-            }
-        };
+const _truncateDescription = (text, maxLen = 50) => {
+    if (!text) return '无描述';
+    // 移除引号
+    text = text.replace(/^["']|["']$/g, '');
+    if (text.length <= maxLen) return text;
+    return text.substring(0, maxLen - 3) + '...';
+};
 
-        process.stdin.on('keypress', onKeypress);
-    });
+/**
+ * 选择目标路径
+ * @returns {Promise<Object|null>} 选中的目标路径配置
+ */
+const _selectTargetPath = async () => {
+    const targetPaths = _getTargetPaths();
+    const selected = await selectSingle(targetPaths, '选择安装目标路径');
+    return selected;
 };
 
 /**
- * 交互式多选菜单（仅选择阶段）
+ * 选择技能（多选菜单）
  * @param {Array} skills 技能列表
  * @param {string} title 菜单标题
- * @param {Object} options 显示选项
- * @param {boolean} options.showSource 是否显示来源
- * @param {boolean} options.showDescription 是否显示描述
- * @param {boolean} options.showVersion 是否显示版本
- * @returns {Promise<Object>} { indices: 选中的索引列表, names: 选中的名称列表 }
+ * @returns {Promise<Array>} 选中的技能索引列表
  */
-const _selectSkillsMenu = (skills, title = '技能安装菜单', options = {}) => {
-    const { showSource = false, showDescription = true, showVersion = true } = options;
+const _selectSkills = async (skills, title) => {
+    // 对于远程技能（官方），不显示描述
+    const showDescription = false;
 
     return new Promise((resolve) => {
         const selected = new Array(skills.length).fill(false);
         let cursor = 0;
 
         const maxNameLen = Math.max(...skills.map(s => s.name.length), 4);
-        const maxSourceLen = showSource ? Math.max(...skills.map(s => (s.source || '').length), 4) : 0;
         const maxTypeLen = Math.max(...skills.map(s => (s.skillType || '').length), 4);
 
         const render = () => {
@@ -357,20 +310,7 @@ const _selectSkillsMenu = (skills, title = '技能安装菜单', options = {}) =
                 const checkbox = selected[index] ? '[✓]'.green : '[ ]';
                 const pointer = isActive ? '▸'.cyan : ' ';
                 const name = skill.name.padEnd(maxNameLen);
-                const version = (showVersion && skill.version) ? `v${skill.version}`.yellow : '';
-                
-                // 来源标记
-                let sourceTag = '';
-                if (showSource && skill.source) {
-                    if (skill.source === SOURCE_GLOBAL) {
-                        sourceTag = `[${skill.source}]`.gray;
-                    } else if (skill.source === SOURCE_PROJECT) {
-                        sourceTag = `[${skill.source}]`.magenta;
-                    } else {
-                        sourceTag = `[${skill.source}]`.gray;
-                    }
-                    sourceTag = sourceTag.padEnd(maxSourceLen + 10); // 补偿颜色码长度
-                }
+                const version = skill.version ? `v${skill.version}`.yellow : '';
                 
                 // 技能类型标记（限定技/通用技）
                 const skillType = skill.skillType || '通用技';
@@ -378,16 +318,13 @@ const _selectSkillsMenu = (skills, title = '技能安装菜单', options = {}) =
                     ? `[${skillType}]`.red 
                     : `[${skillType}]`.green;
                 // 统一对齐：限定技和通用技都是3个字符，使用固定宽度确保对齐
-                // 实际显示宽度 = 方括号(2) + 文本(3) + 颜色码补偿(约15-20)
                 const typeTagPadded = typeTag.padEnd(25); // 固定宽度确保对齐
 
-                if (isActive) {
-                    console.log(`  ${pointer} ${checkbox} ${sourceTag}${typeTagPadded}${name.cyan.bold}  ${version}`);
-                } else {
-                    console.log(`  ${pointer} ${checkbox} ${sourceTag}${typeTagPadded}${name.cyan}  ${version}`);
-                }
+                // 统一技能名称样式，不加粗
+                const nameStyled = isActive ? name.cyan.bold : name.cyan;
+                console.log(`  ${pointer} ${checkbox} ${typeTagPadded}${nameStyled}  ${version}`);
 
-                // 显示描述（可选）
+                // 显示描述（可选，远程技能不显示）
                 if (showDescription) {
                     const desc = _truncateDescription(skill.description, 50);
                     console.log(`       ${desc.gray}`);
@@ -439,7 +376,7 @@ const _selectSkillsMenu = (skills, title = '技能安装菜单', options = {}) =
                 process.stdin.setRawMode(false);
                 process.stdin.removeListener('keypress', onKeypress);
                 process.stdout.write('\x1B[2J\x1B[0f');
-                resolve({ indices: [], names: [] });
+                resolve([]);
                 return;
             }
 
@@ -493,36 +430,26 @@ const _selectSkillsMenu = (skills, title = '技能安装菜单', options = {}) =
                 });
                 console.log('');
 
-                resolve(result);
+                // 等待用户确认
+                resolve(result.indices);
                 return;
             }
         };
 
         process.stdin.on('keypress', onKeypress);
-    });
-};
-
-/**
- * 交互式选择技能（包含确认步骤）
- * @param {Array} skills 技能列表
- * @param {string} title 菜单标题
- * @param {Object} options 显示选项
- * @returns {Promise<Array>} 选中的技能索引列表
- */
-const _selectSkills = async (skills, title, options = {}) => {
-    const result = await _selectSkillsMenu(skills, title, options);
-    
-    if (result.indices.length === 0) {
-        return [];
-    }
+    }).then(async (indices) => {
+        if (indices.length === 0) {
+            return [];
+        }
 
-    const answer = await Ec.ask('确认安装？(y/N): ');
-    if (answer.trim().toLowerCase() === 'y' || answer.trim().toLowerCase() === 'yes') {
-        return result.indices;
-    } else {
-        Ec.waiting('已取消安装');
-        return [];
-    }
+        const answer = await Ec.ask('确认安装？(y/N): ');
+        if (answer.trim().toLowerCase() === 'y' || answer.trim().toLowerCase() === 'yes') {
+            return indices;
+        } else {
+            Ec.waiting('已取消安装');
+            return [];
+        }
+    });
 };
 
 /**
@@ -552,75 +479,44 @@ const _installSkills = async (skills, selectedIndices, targetDir) => {
 };
 
 /**
- * 从本地安装技能（扫描全局和项目目录）
- * @param {boolean} isGlobal 是否安装到全局目录
+ * 选择远程仓库
+ * @param {Array} repositories 仓库列表
+ * @param {string} remoteValue -r 参数的值（如果提供）
+ * @returns {Promise<Object|null>} 选中的仓库
  */
-const _installFromLocal = async (isGlobal = false) => {
-    const allSkills = [];
-
-    // 1. 扫描全局技能目录
-    Ec.waiting('正在扫描全局技能仓库...');
-    if (fs.existsSync(GLOBAL_SKILLS_DIR)) {
-        const globalSkills = _scanSkillsFromDir(GLOBAL_SKILLS_DIR, SOURCE_GLOBAL);
-        allSkills.push(...globalSkills);
-        Ec.waiting(`  找到 ${globalSkills.length} 个全局技能`);
-    } else {
-        Ec.waiting(`  全局目录不存在: ${GLOBAL_SKILLS_DIR}`.gray);
-    }
-
-    // 2. 扫描当前项目技能目录
-    const projectDir = process.cwd();
-    const projectSkillsDir = path.join(projectDir, 'skills');
-    
-    Ec.waiting('正在扫描项目技能目录...');
-    if (fs.existsSync(projectSkillsDir)) {
-        const projectSkills = _scanSkillsFromDir(projectSkillsDir, SOURCE_PROJECT);
-        allSkills.push(...projectSkills);
-        Ec.waiting(`  找到 ${projectSkills.length} 个项目技能`);
-    } else {
-        Ec.waiting(`  项目目录不存在: ${projectSkillsDir}`.gray);
-    }
-
-    // 检查是否有可用技能
-    if (allSkills.length === 0) {
-        Ec.warn('未找到任何可用技能');
-        Ec.waiting(`请在 ${GLOBAL_SKILLS_DIR} 或 ${projectSkillsDir} 目录下添加技能`);
-        Ec.waiting('或使用 -r 参数从远程仓库安装');
-        process.exit(0);
-    }
-
-    Ec.info(`共找到 ${allSkills.length} 个本地技能，正在打开选择菜单...`);
-
-    const selectedIndices = await _selectSkills(allSkills, '本地技能安装', {
-        showSource: true,
-        showDescription: true,
-        showVersion: true
-    });
-
-    if (selectedIndices.length === 0) {
-        Ec.waiting('未选择任何技能，退出');
-        process.exit(0);
+const _selectRepository = async (repositories, remoteValue) => {
+    // 如果 -r 有值，直接查找对应的仓库
+    if (remoteValue) {
+        const repo = repositories.find(r => 
+            r.name === remoteValue || 
+            r.name.toLowerCase() === remoteValue.toLowerCase()
+        );
+        if (repo) {
+            return repo;
+        }
+        Ec.warn(`未找到仓库: ${remoteValue}`);
+        Ec.waiting('将显示仓库选择菜单...');
     }
 
-    // 根据 -g 参数决定安装位置
-    const targetDir = isGlobal 
-        ? GLOBAL_SKILLS_DIR 
-        : path.join(projectDir, '.claude', 'skills');
-
-    console.log('');
-    Ec.info(`将安装 ${selectedIndices.length} 个技能到 ${targetDir}`);
-
-    await _installSkills(allSkills, selectedIndices, targetDir);
+    // 显示仓库选择菜单
+    const menuItems = repositories.map(repo => ({
+        name: repo.name,
+        description: `${repo.description || ''} - ${repo.url}`,
+        repo: repo  // 保存原始仓库对象的引用
+    }));
 
-    Ec.info(`✅ 成功安装 ${selectedIndices.length} 个技能！`);
+    const selected = await selectSingle(menuItems, '选择远程仓库');
+    
+    // 返回原始仓库对象
+    return selected ? selected.repo : null;
 };
 
 /**
  * 从远程仓库安装技能
  * @param {Object} repository 仓库配置
- * @param {boolean} isGlobal 是否安装到全局目录
+ * @param {string} targetPath 目标路径
  */
-const _installFromRemote = async (repository, isGlobal = false) => {
+const _installFromRemote = async (repository, targetPath) => {
     const projectDir = process.cwd();
     
     console.log('');
@@ -660,88 +556,56 @@ const _installFromRemote = async (repository, isGlobal = false) => {
 
     Ec.info(`找到 ${skills.length} 个远程技能，正在打开选择菜单...`);
 
-    const selectedIndices = await _selectSkills(skills, `远程技能 (${repository.name})`, {
-        showSource: false,
-        showDescription: false,
-        showVersion: false
-    });
+    const selectedIndices = await _selectSkills(skills, `远程技能 (${repository.name})`);
 
     if (selectedIndices.length === 0) {
         Ec.waiting('未选择任何技能，退出');
         return;
     }
 
-    // 根据 -g 参数决定安装位置
-    const targetDir = isGlobal 
-        ? GLOBAL_SKILLS_DIR 
-        : path.join(projectDir, '.claude', 'skills');
-
     console.log('');
-    Ec.info(`将安装 ${selectedIndices.length} 个技能到 ${targetDir}`);
+    Ec.info(`将安装 ${selectedIndices.length} 个技能到 ${targetPath}`);
 
-    await _installSkills(skills, selectedIndices, targetDir);
+    await _installSkills(skills, selectedIndices, targetPath);
 
     Ec.info(`✅ 成功安装 ${selectedIndices.length} 个技能！`);
 };
 
 module.exports = async (options) => {
-    try {
-        // 解析 -r 和 -g 参数
-        const { hasRemote, remoteValue } = _parseRemoteArg();
-        const isGlobal = _parseGlobalArg();
-
-        // 显示安装目标信息
-        if (isGlobal) {
-            console.log('');
-            Ec.info(`📦 安装目标: 全局目录 (${GLOBAL_SKILLS_DIR.cyan})`);
-        } else {
-            const projectDir = process.cwd();
-            const projectSkillsDir = path.join(projectDir, '.claude', 'skills');
-            console.log('');
-            Ec.info(`📦 安装目标: 项目目录 (${projectSkillsDir.cyan})`);
-        }
-
-        if (!hasRemote) {
-            // 不带 -r：从本地安装
-            await _installFromLocal(isGlobal);
-            process.exit(0);
-        }
-
-        // 带 -r 参数：从远程安装
-        const repositories = _loadRepositories();
-
-        if (repositories.length === 0) {
-            Ec.error('❌ 未配置任何远程仓库');
-            Ec.waiting(`请在 ${REPOSITORIES_CONFIG} 中配置仓库`);
-            process.exit(1);
-        }
+    // 检查 -r 参数
+    const { hasFlag: hasRemote, value: remoteValue } = parseOptional('remote', 'r');
+    
+    if (!hasRemote) {
+        Ec.error('❌ 此命令必须使用 -r 参数指定远程仓库');
+        Ec.waiting('用法: momo apply -r [仓库名]');
+        process.exit(1);
+    }
 
-        let selectedRepo = null;
+    // 加载远程仓库配置
+    const repositories = _loadRepositories();
+    
+    if (repositories.length === 0) {
+        Ec.error('❌ 未找到任何远程仓库配置');
+        Ec.waiting(`请检查配置文件: ${REPOSITORIES_CONFIG}`);
+        process.exit(1);
+    }
 
-        if (remoteValue) {
-            // -r 有值：直接使用指定仓库
-            selectedRepo = repositories.find(r => r.name === remoteValue);
-            if (!selectedRepo) {
-                Ec.error(`❌ 未找到仓库: ${remoteValue}`);
-                Ec.waiting('可用的仓库:');
-                repositories.forEach(r => {
-                    Ec.waiting(`  - ${r.name}`);
-                });
-                process.exit(1);
-            }
-        } else {
-            // -r 无值：显示仓库选择菜单
-            selectedRepo = await _selectRepository(repositories);
-            if (!selectedRepo) {
-                Ec.waiting('未选择任何仓库，退出');
-                process.exit(0);
-            }
-        }
+    // 选择仓库
+    const repository = await _selectRepository(repositories, remoteValue);
+    if (!repository) {
+        Ec.waiting('已取消选择仓库');
+        process.exit(0);
+    }
 
-        await _installFromRemote(selectedRepo, isGlobal);
+    // 选择目标路径
+    const targetPathConfig = await _selectTargetPath();
+    if (!targetPathConfig) {
+        Ec.waiting('已取消选择目标路径');
         process.exit(0);
-    } catch (error) {
-        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
-        process.exit(1);
     }
+
+    // 从远程仓库安装技能
+    await _installFromRemote(repository, targetPathConfig.path);
+    
+    process.exit(0);
 };