momo-ai 1.0.19 → 1.0.21

package/src/executor/executeSkills.js

@@ -0,0 +1,747 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+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 { copyDir, readJson, parseFile } = require('../utils/momo-file-utils');
+
+// 全局技能仓库路径
+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';
+
+/**
+ * 确保 .r2mo/repo 在 .gitignore 中
+ * @param {string} projectDir 项目目录
+ */
+const _ensureGitIgnore = (projectDir) => {
+    const gitignorePath = path.join(projectDir, '.gitignore');
+    const ignoreEntry = '.r2mo/repo';
+    
+    try {
+        let content = '';
+        if (fs.existsSync(gitignorePath)) {
+            content = fs.readFileSync(gitignorePath, 'utf8');
+        }
+        
+        // 检查是否已经存在
+        const lines = content.split('\n');
+        const hasEntry = lines.some(line => line.trim() === ignoreEntry);
+        
+        if (!hasEntry) {
+            // 添加到 .gitignore
+            const newContent = content.endsWith('\n') || content === '' 
+                ? content + ignoreEntry + '\n'
+                : content + '\n' + ignoreEntry + '\n';
+            fs.writeFileSync(gitignorePath, newContent);
+            Ec.waiting(`已将 ${ignoreEntry} 添加到 .gitignore`);
+        }
+    } catch (error) {
+        Ec.warn(`更新 .gitignore 失败: ${error.message}`);
+    }
+};
+
+/**
+ * 获取仓库本地缓存路径
+ * @param {string} projectDir 项目目录
+ * @param {string} repoName 仓库名称
+ * @returns {string} 本地缓存路径
+ */
+const _getLocalRepoPath = (projectDir, repoName) => {
+    // 将 / 替换为 - 避免路径问题
+    const safeName = repoName.replace(/\//g, '-');
+    return path.join(projectDir, LOCAL_REPO_CACHE_DIR, safeName);
+};
+
+/**
+ * 克隆或更新远程仓库到本地缓存
+ * @param {string} url 仓库 URL
+ * @param {string} localPath 本地缓存路径
+ * @returns {boolean} 是否成功
+ */
+const _cloneOrUpdateRepository = (url, localPath) => {
+    // 确保父目录存在
+    const parentDir = path.dirname(localPath);
+    if (!fs.existsSync(parentDir)) {
+        fs.mkdirSync(parentDir, { recursive: true });
+    }
+    
+    // 检查是否已有本地缓存
+    if (fs.existsSync(localPath)) {
+        Ec.waiting(`发现本地缓存: ${localPath}`.cyan);
+        Ec.waiting('正在拉取最新更新...');
+        try {
+            execSync(`cd "${localPath}" && git pull --quiet`, {
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            Ec.waiting('✓ 仓库已更新'.green);
+            return true;
+        } catch (error) {
+            Ec.warn(`更新失败，将重新克隆: ${error.message}`);
+            // 删除损坏的缓存
+            fs.rmSync(localPath, { recursive: true, force: true });
+        }
+    }
+    
+    // 克隆仓库
+    Ec.waiting(`正在克隆仓库: ${url}`.cyan);
+    Ec.waiting(`本地缓存: ${localPath}`);
+    
+    try {
+        execSync(`git clone --depth 1 "${url}" "${localPath}"`, {
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        Ec.waiting('✓ 仓库克隆完成'.green);
+        return true;
+    } catch (error) {
+        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} 仓库列表
+ */
+const _loadRepositories = () => {
+    try {
+        const config = readJson(REPOSITORIES_CONFIG);
+        return config ? (config.repositories || []) : [];
+    } catch (error) {
+        Ec.warn(`读取仓库配置失败: ${error.message}`);
+        return [];
+    }
+};
+
+/**
+ * 解析 SKILL.md 文件的 YAML 头部
+ * @param {string} filePath SKILL.md 文件路径
+ * @returns {Object|null} 解析的元数据对象
+ */
+const _parseSkillYaml = (filePath) => {
+    const parsed = parseFile(filePath);
+    return parsed ? parsed.attributes : null;
+};
+
+/**
+ * 扫描技能目录
+ * @param {string} skillsDir 技能目录路径
+ * @param {string} source 来源标记
+ * @returns {Array} 技能列表
+ */
+const _scanSkillsFromDir = (skillsDir, source = '') => {
+    const skills = [];
+
+    if (!fs.existsSync(skillsDir)) {
+        return skills;
+    }
+
+    const items = fs.readdirSync(skillsDir);
+
+    for (const item of items) {
+        const skillDir = path.join(skillsDir, item);
+        
+        try {
+            const stat = fs.statSync(skillDir);
+
+            if (stat.isDirectory()) {
+                const skillFile = path.join(skillDir, 'SKILL.md');
+                const metadata = _parseSkillYaml(skillFile);
+
+                if (metadata) {
+                    // 判断技能类型：检查 repository 字段
+                    const repository = metadata.repository || '';
+                    const skillType = repository === RESTRICTED_REPOSITORY ? '限定技' : '通用技';
+                    
+                    skills.push({
+                        dirname: item,
+                        path: skillDir,
+                        name: metadata.name || item,
+                        description: metadata.description || '无描述',
+                        version: metadata.version || '未知',
+                        category: metadata.category || '未分类',
+                        tags: metadata.tags || [],
+                        source: source,
+                        skillType: skillType,
+                        repository: repository
+                    });
+                } else {
+                    skills.push({
+                        dirname: item,
+                        path: skillDir,
+                        name: item,
+                        description: '(未找到 SKILL.md)',
+                        version: '未知',
+                        category: '未分类',
+                        tags: [],
+                        source: source,
+                        skillType: '通用技',
+                        repository: ''
+                    });
+                }
+            }
+        } catch (e) {
+            // 忽略无法访问的目录
+        }
+    }
+
+    return skills;
+};
+
+
+/**
+ * 递归拷贝目录（使用工具函数）
+ * @param {string} src 源目录
+ * @param {string} dest 目标目录
+ */
+const _copyDirectory = async (src, dest) => {
+    await copyDir(src, dest);
+};
+
+/**
+ * 仓库选择菜单
+ * @param {Array} repositories 仓库列表
+ * @returns {Promise<Object|null>} 选中的仓库
+ */
+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;
+            }
+        };
+
+        process.stdin.on('keypress', onKeypress);
+    });
+};
+
+/**
+ * 交互式多选菜单（仅选择阶段）
+ * @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: 选中的名称列表 }
+ */
+const _selectSkillsMenu = (skills, title = '技能安装菜单', options = {}) => {
+    const { showSource = false, showDescription = true, showVersion = true } = options;
+
+    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 = () => {
+            process.stdout.write('\x1B[2J\x1B[0f');
+
+            console.log('');
+            console.log('[Momo AI]'.blue.bold + ` ====== ${title} ======`.blue);
+            console.log('');
+
+            skills.forEach((skill, index) => {
+                const isActive = index === cursor;
+                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 skillType = skill.skillType || '通用技';
+                const typeTag = skillType === '限定技' 
+                    ? `[${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}`);
+                }
+
+                // 显示描述（可选）
+                if (showDescription) {
+                    const desc = _truncateDescription(skill.description, 50);
+                    console.log(`       ${desc.gray}`);
+                }
+            });
+
+            console.log('');
+            console.log('  ─────────────────────────────────────────────────'.gray);
+            console.log('  ↑/↓ 移动  │  空格 选择/取消  │  a 全选  │  n 清空  │  回车 确认  │  q 退出'.gray);
+            console.log('');
+
+            const selectedCount = selected.filter(s => s).length;
+            if (selectedCount > 0) {
+                console.log(`  已选择 ${selectedCount} 个技能`.green);
+            } else {
+                console.log('  未选择任何技能'.yellow);
+            }
+        };
+
+        const getSelectedResult = () => {
+            const indices = [];
+            const names = [];
+            selected.forEach((sel, idx) => {
+                if (sel) {
+                    indices.push(idx);
+                    names.push(skills[idx].name);
+                }
+            });
+            return { indices, names };
+        };
+
+        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({ indices: [], names: [] });
+                return;
+            }
+
+            if (key.name === 'up') {
+                cursor = cursor > 0 ? cursor - 1 : skills.length - 1;
+                render();
+                return;
+            }
+
+            if (key.name === 'down') {
+                cursor = cursor < skills.length - 1 ? cursor + 1 : 0;
+                render();
+                return;
+            }
+
+            if (key.name === 'space') {
+                selected[cursor] = !selected[cursor];
+                render();
+                return;
+            }
+
+            if (key.name === 'a') {
+                selected.fill(true);
+                render();
+                return;
+            }
+
+            if (key.name === 'n') {
+                selected.fill(false);
+                render();
+                return;
+            }
+
+            if (key.name === 'return') {
+                const result = getSelectedResult();
+                
+                if (result.indices.length === 0) {
+                    render();
+                    return;
+                }
+
+                process.stdin.setRawMode(false);
+                process.stdin.removeListener('keypress', onKeypress);
+                
+                process.stdout.write('\x1B[2J\x1B[0f');
+                console.log('');
+                console.log('[Momo AI]'.blue.bold + ' 即将安装以下技能:');
+                console.log('');
+                result.names.forEach(name => {
+                    console.log(`  ✓ ${name}`.green);
+                });
+                console.log('');
+
+                resolve(result);
+                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 [];
+    }
+
+    const answer = await Ec.ask('确认安装？(y/N): ');
+    if (answer.trim().toLowerCase() === 'y' || answer.trim().toLowerCase() === 'yes') {
+        return result.indices;
+    } else {
+        Ec.waiting('已取消安装');
+        return [];
+    }
+};
+
+/**
+ * 安装选中的技能
+ * @param {Array} skills 技能列表
+ * @param {Array} selectedIndices 选中的索引
+ * @param {string} targetDir 目标目录
+ */
+const _installSkills = async (skills, selectedIndices, targetDir) => {
+    await fsAsync.mkdir(targetDir, { recursive: true });
+
+    for (const index of selectedIndices) {
+        const skill = skills[index];
+        const destPath = path.join(targetDir, skill.dirname);
+
+        Ec.waiting(`正在安装技能: ${skill.name}`.cyan);
+
+        if (fs.existsSync(destPath)) {
+            Ec.warn(`  技能 "${skill.name}" 已存在，将覆盖...`);
+            await fsAsync.rm(destPath, { recursive: true, force: true });
+        }
+
+        await _copyDirectory(skill.path, destPath);
+
+        Ec.waiting(`  ✓ 已安装到 ${destPath}`.green);
+    }
+};
+
+/**
+ * 从本地安装技能（扫描全局和项目目录）
+ * @param {boolean} isGlobal 是否安装到全局目录
+ */
+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);
+    }
+
+    // 根据 -g 参数决定安装位置
+    const targetDir = isGlobal 
+        ? GLOBAL_SKILLS_DIR 
+        : path.join(projectDir, '.claude', 'skills');
+
+    console.log('');
+    Ec.info(`将安装 ${selectedIndices.length} 个技能到 ${targetDir}`);
+
+    await _installSkills(allSkills, selectedIndices, targetDir);
+
+    Ec.info(`✅ 成功安装 ${selectedIndices.length} 个技能！`);
+};
+
+/**
+ * 从远程仓库安装技能
+ * @param {Object} repository 仓库配置
+ * @param {boolean} isGlobal 是否安装到全局目录
+ */
+const _installFromRemote = async (repository, isGlobal = false) => {
+    const projectDir = process.cwd();
+    
+    console.log('');
+    Ec.info(`已选择仓库: ${repository.name}`);
+    Ec.waiting(`仓库地址: ${repository.url}`);
+    Ec.waiting(`技能目录: ${repository.skillsPath || 'skills'}`);
+    console.log('');
+
+    // 确保 .r2mo/repo 在 .gitignore 中
+    _ensureGitIgnore(projectDir);
+
+    // 获取本地缓存路径
+    const localRepoPath = _getLocalRepoPath(projectDir, repository.name);
+
+    // 克隆或更新仓库
+    const success = _cloneOrUpdateRepository(repository.url, localRepoPath);
+    if (!success) {
+        return;
+    }
+
+    // 检查技能目录是否存在
+    const skillsPath = path.join(localRepoPath, repository.skillsPath || 'skills');
+    
+    if (!fs.existsSync(skillsPath)) {
+        Ec.error(`❌ 仓库中未找到技能目录: ${repository.skillsPath || 'skills'}`);
+        Ec.waiting('请检查仓库配置中的 skillsPath 是否正确');
+        return;
+    }
+
+    Ec.waiting('✓ 技能目录存在，正在扫描...'.green);
+    const skills = _scanSkillsFromDir(skillsPath);
+
+    if (skills.length === 0) {
+        Ec.warn('技能目录存在，但未找到任何有效技能');
+        return;
+    }
+
+    Ec.info(`找到 ${skills.length} 个远程技能，正在打开选择菜单...`);
+
+    const selectedIndices = await _selectSkills(skills, `远程技能 (${repository.name})`, {
+        showSource: false,
+        showDescription: false,
+        showVersion: false
+    });
+
+    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}`);
+
+    await _installSkills(skills, selectedIndices, targetDir);
+
+    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);
+        }
+
+        let selectedRepo = null;
+
+        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);
+            }
+        }
+
+        await _installFromRemote(selectedRepo, isGlobal);
+        process.exit(0);
+    } catch (error) {
+        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        process.exit(1);
+    }
+};