momo-ai 1.0.20 → 1.0.21

package/src/executor/executeMcp.js

@@ -0,0 +1,290 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const Ec = require('../epic');
+
+// 源 MCP 脚本路径
+const SOURCE_MCP_SCRIPT = path.join(__dirname, '../_mcp/skills-server.mjs');
+
+// 必需的依赖包
+const REQUIRED_DEPS = ['@modelcontextprotocol/sdk', 'zod', 'front-matter', 'chokidar'];
+
+/**
+ * 检查依赖是否已安装
+ */
+const _checkDependencies = () => {
+    const missing = [];
+    const projectRoot = path.join(__dirname, '../..');
+    for (const dep of REQUIRED_DEPS) {
+        const depPath = path.join(projectRoot, 'node_modules', dep);
+        if (!fs.existsSync(depPath)) {
+            missing.push(dep);
+        }
+    }
+    return { installed: missing.length === 0, missing };
+};
+
+/**
+ * 显示依赖安装命令
+ */
+const _showInstallCommand = (missing) => {
+    console.log('');
+    Ec.error('❌ 缺少必要依赖，请先安装：');
+    console.log(`  npm install ${missing.join(' ')}`.cyan);
+    console.log('');
+};
+
+/**
+ * 生成 MCP 脚本内容
+ */
+const _getMcpScriptContent = () => {
+    return `#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import fs from "fs/promises";
+import fsSync from "fs";
+import path from "path";
+import fm from "front-matter";
+import os from "os";
+
+const GLOBAL_SKILLS_DIR = process.env.MOMO_GLOBAL_SKILLS_DIR || path.join(os.homedir(), '.claude', 'skills');
+const PROJECT_SKILLS_DIR = process.env.MOMO_PROJECT_SKILLS_DIR || path.join(process.cwd(), '.claude', 'skills');
+
+const server = new McpServer({ name: "MomoSkills", version: "2.0.0" });
+
+async function parseSkillFile(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf8");
+    const parsed = fm(content);
+    return { attributes: parsed.attributes, body: parsed.body };
+  } catch (err) { return null; }
+}
+
+async function scanAndRegister(dir, source) {
+    if (!fsSync.existsSync(dir)) return;
+    try {
+        const items = await fs.readdir(dir);
+        for (const item of items) {
+            const skillDir = path.join(dir, item);
+            try {
+                if ((await fs.stat(skillDir)).isDirectory()) {
+                    const skillFile = path.join(skillDir, 'SKILL.md');
+                    if (fsSync.existsSync(skillFile)) {
+                         await registerTool(item, skillFile, source);
+                    }
+                }
+            } catch(e){}
+        }
+    } catch(e) {}
+}
+
+async function registerTool(folderName, filePath, source) {
+    try {
+        const parsed = await parseSkillFile(filePath);
+        if(!parsed || !parsed.attributes) return;
+        const attr = parsed.attributes;
+        const toolName = attr.name || folderName;
+        
+        const argsSchema = {};
+        if (Array.isArray(attr.arguments)) {
+             attr.arguments.forEach(arg => {
+                 argsSchema[arg.name] = z.string().describe(arg.description || "");
+             });
+        }
+
+        server.tool(toolName, attr.description || "No desc", argsSchema, async (args) => {
+            let res = parsed.body;
+            for (const [k, v] of Object.entries(args)) res = res.replace(new RegExp(\`{{\\\${k}}}\`, 'g'), v);
+            return { content: [{ type: "text", text: res }] };
+        });
+    } catch(e) { console.error(e); }
+}
+
+async function main() {
+  await scanAndRegister(PROJECT_SKILLS_DIR, 'project');
+  await scanAndRegister(GLOBAL_SKILLS_DIR, 'global');
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch(err => { console.error(err); process.exit(1); });
+`;
+};
+
+/**
+ * 确保源 MCP 脚本存在
+ */
+const _ensureSourceScript = () => {
+    const mcpDir = path.dirname(SOURCE_MCP_SCRIPT);
+    if (!fs.existsSync(mcpDir)) {
+        fs.mkdirSync(mcpDir, { recursive: true });
+    }
+    fs.writeFileSync(SOURCE_MCP_SCRIPT, _getMcpScriptContent());
+};
+
+/**
+ * 拷贝 MCP 脚本到项目目录
+ * @param {string} projectDir 项目目录
+ * @returns {string} 目标脚本路径
+ */
+const _copyMcpScriptToProject = (projectDir) => {
+    const targetDir = path.join(projectDir, '.r2mo', 'mcpserver');
+    const targetScript = path.join(targetDir, 'skills-server.mjs');
+    
+    // 创建目录
+    if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+        Ec.waiting(`创建目录: ${targetDir}`);
+    }
+    
+    // 拷贝脚本
+    const content = _getMcpScriptContent();
+    fs.writeFileSync(targetScript, content);
+    Ec.waiting(`✓ MCP 脚本已拷贝到: ${targetScript}`);
+    
+    return targetScript;
+};
+
+/**
+ * 更新 .cursor/mcp.json 配置
+ * @param {string} projectDir 项目目录
+ * @param {string} mcpScriptPath MCP 脚本路径
+ * @param {string} skillsDir 技能目录路径
+ */
+const _updateMcpConfig = (projectDir, mcpScriptPath, skillsDir) => {
+    const cursorDir = path.join(projectDir, '.cursor');
+    const mcpConfigPath = path.join(cursorDir, 'mcp.json');
+    
+    // 确保 .cursor 目录存在
+    if (!fs.existsSync(cursorDir)) {
+        fs.mkdirSync(cursorDir, { recursive: true });
+        Ec.waiting(`创建目录: ${cursorDir}`);
+    }
+    
+    // 读取现有配置或创建新配置
+    let config = { mcpServers: {} };
+    
+    if (fs.existsSync(mcpConfigPath)) {
+        try {
+            const content = fs.readFileSync(mcpConfigPath, 'utf8');
+            config = JSON.parse(content);
+            if (!config.mcpServers) {
+                config.mcpServers = {};
+            }
+            Ec.waiting(`读取现有配置: ${mcpConfigPath}`);
+        } catch (e) {
+            Ec.warn(`配置文件解析失败，将创建新配置`);
+            config = { mcpServers: {} };
+        }
+    }
+    
+    // 添加/更新 momo-skills 配置
+    config.mcpServers['momo-skills'] = {
+        command: 'node',
+        args: [mcpScriptPath],
+        env: {
+            NODE_ENV: 'production',
+            MOMO_PROJECT_SKILLS_DIR: skillsDir,
+            MOMO_GLOBAL_SKILLS_DIR: path.join(os.homedir(), '.claude', 'skills')
+        },
+        disabled: false,
+        alwaysAllow: []
+    };
+    
+    // 写入配置
+    fs.writeFileSync(mcpConfigPath, JSON.stringify(config, null, 2));
+    Ec.info(`✓ MCP 配置已更新: ${mcpConfigPath}`);
+    
+    return mcpConfigPath;
+};
+
+/**
+ * 确保 .r2mo/mcpserver 在 .gitignore 中
+ * @param {string} projectDir 项目目录
+ */
+const _ensureGitIgnore = (projectDir) => {
+    const gitignorePath = path.join(projectDir, '.gitignore');
+    const ignoreEntry = '.r2mo/mcpserver';
+    
+    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) {
+            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}`);
+    }
+};
+
+module.exports = async (options) => {
+    try {
+        const projectDir = process.cwd();
+        const skillsDir = path.join(projectDir, '.claude', 'skills');
+        
+        // 1. 检查依赖
+        Ec.waiting('正在检查依赖...');
+        const { installed, missing } = _checkDependencies();
+        
+        if (!installed) {
+            _showInstallCommand(missing);
+            process.exit(1);
+        }
+        Ec.info('✓ 所有依赖已安装');
+        
+        // 2. 确保源脚本存在
+        _ensureSourceScript();
+        
+        // 3. 拷贝 MCP 脚本到项目
+        console.log('');
+        const mcpScriptPath = _copyMcpScriptToProject(projectDir);
+        
+        // 4. 更新 .cursor/mcp.json
+        console.log('');
+        const mcpConfigPath = _updateMcpConfig(projectDir, mcpScriptPath, skillsDir);
+        
+        // 5. 更新 .gitignore
+        _ensureGitIgnore(projectDir);
+        
+        // 6. 显示结果
+        // 将项目目录内的绝对路径转换为 {ROOT} 相对路径
+        const formatPath = (absPath) => {
+            if (absPath.startsWith(projectDir)) {
+                return absPath.replace(projectDir, '{ROOT}');
+            }
+            return absPath;
+        };
+        
+        const globalSkillsPath = path.join(os.homedir(), '.claude', 'skills');
+        
+        console.log('');
+        console.log('─'.repeat(60));
+        console.log(' MCP Skills Server 配置完成'.green);
+        console.log('─'.repeat(60));
+        console.log(` 脚本位置: ${formatPath(mcpScriptPath)}`);
+        console.log(` 配置文件: ${formatPath(mcpConfigPath)}`);
+        console.log(` 项目技能: ${formatPath(skillsDir)}`);
+        console.log(` 全局技能: ${globalSkillsPath}`);
+        console.log('─'.repeat(60));
+        console.log('');
+        console.log(`  {ROOT} = 当前目录`.gray);
+        console.log('');
+        
+        Ec.info('🎉 配置完成！重启 Cursor 后生效');
+        
+        process.exit(0);
+    } catch (error) {
+        Ec.error(`❌ 执行失败: ${error.message}`);
+        process.exit(1);
+    }
+};

package/src/executor/executeOpen.js

@@ -1,159 +1,178 @@
+const fs = require('fs');
+const path = require('path');
 const Ec = require('../epic');
-const {spawn} = require('child_process');
-
-module.exports = async (options) => {
-    // 参数提取
-    const parsed = Ec.parseArgument(options);
-
-    try {
-        // 定义可用的AI工具
-        const aiTools = [
-            {name: 'Trae', command: 'trae'},
-            {name: 'Cursor', command: 'cursor'},
-            {name: 'Lingma', command: 'lingma'},
-            {name: 'Kiro', command: 'kiro'}
-        ];
-
-        // 检查哪些工具可用
-        const availableTools = [];
-        for (const tool of aiTools) {
-            if (await _isCommandAvailable(tool.command)) {
-                availableTools.push(tool);
-            }
-        }
-
-        // 如果没有可用工具，提示用户安装
-        if (availableTools.length === 0) {
-            Ec.error('❌ 未找到可用的AI工具，请确保已安装以下工具之一：Trae、Cursor、Lingma、Kiro');
-            Ec.askClose();
-            process.exit(1);
-        }
-
-        // 如果只有一个工具可用，直接使用它
-        if (availableTools.length === 1) {
-            const tool = availableTools[0];
-            let toolDisplayName = tool.name;
-            if (tool.name === 'Trae' || tool.name === 'Cursor') {
-                toolDisplayName = `${tool.name}（${'Multi-Agent'.cyan}）`;
-            }
-            if (tool.name === 'Trae') {
-                Ec.waiting(`🔍 检测到可用工具: ${toolDisplayName.green}`);
-            } else {
-                Ec.waiting(`🔍 检测到可用工具: ${toolDisplayName}`);
-            }
-            await _openWithTool(tool.command);
-            Ec.askClose();
-            process.exit(0);
-        }
-
-        // 显示交互式选择菜单
-        Ec.waiting('🔍 检测到多个可用的AI工具，请选择要使用的工具:');
-        const choices = availableTools.map((tool, index) => {
-            let toolDisplayName = tool.name;
-            if (tool.name === 'Trae' || tool.name === 'Cursor') {
-                toolDisplayName = `${tool.name}（${'Multi-Agent'.cyan}）`;
-            }
-            if (tool.name === 'Trae') {
-                return `${index + 1}. ${toolDisplayName} ${'推荐'.green}`;
-            } else {
-                return `${index + 1}. ${toolDisplayName}`;
-            }
-        });
-
-        // 添加退出选项
-        choices.push(`${choices.length + 1}. 退出`);
-
-        for (const choice of choices) {
-            Ec.waiting(choice);
-        }
-
-        // 获取用户选择
-        const answer = await Ec.ask('请输入选项编号: ');
-        const selectedIndex = parseInt(answer) - 1;
+const { spawn } = require('child_process');
+const { selectSingle } = require('../utils/momo-menu');
+
+// AI 工具配置
+const AI_TOOLS = [
+    {
+        name: 'Antigravity',
+        command: 'antigravity',
+        description: 'Claude Code 官方客户端',
+        openMethod: 'spawn'  // 使用 spawn 直接执行
+    },
+    {
+        name: 'Trae',
+        command: 'trae',
+        description: '字节跳动 AI IDE',
+        openMethod: 'spawn'
+    },
+    {
+        name: 'Cursor',
+        command: 'cursor',
+        description: 'Cursor AI IDE',
+        openMethod: 'spawn'
+    }
+];
 
-        // 检查用户选择
-        if (isNaN(selectedIndex) || selectedIndex < 0 || selectedIndex >= availableTools.length) {
-            if (selectedIndex === availableTools.length) {
-                Ec.waiting('👋 已取消操作');
-                Ec.askClose();
-                process.exit(0);
+/**
+ * 解析 -d 参数
+ * @returns {string|null} 目录路径
+ */
+const _parseDirArg = () => {
+    const args = process.argv.slice(3);
+    
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '-d' || args[i] === '--dir') {
+            const next = args[i + 1];
+            if (next && !next.startsWith('-')) {
+                return next;
             }
-            Ec.error('❌ 无效的选择');
-            Ec.askClose();
-            process.exit(1);
         }
-
-        // 执行选择的工具
-        const selectedTool = availableTools[selectedIndex];
-        let toolDisplayName = selectedTool.name;
-        if (selectedTool.name === 'Trae' || selectedTool.name === 'Cursor') {
-            toolDisplayName = `${selectedTool.name}（${'Multi-Agent'.cyan}）`;
-        }
-        Ec.waiting(`🚀 正在使用 ${toolDisplayName} 打开项目...`);
-        await _openWithTool(selectedTool.command);
-        Ec.askClose();
-        process.exit(0);
-
-    } catch (error) {
-        console.error(error);
-        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
-        if (process.platform === 'win32') {
-            Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
-        }
-        Ec.askClose();
-        process.exit(1);
     }
+    
+    return null;
 };
 
 /**
  * 检查命令是否可用
  * @param {string} command 命令名称
- * @returns {Promise<boolean>} 命令是否可用
+ * @returns {Promise<boolean>}
  */
 const _isCommandAvailable = async (command) => {
     return new Promise((resolve) => {
-        // 在 Windows 上使用 where 命令，在其他系统上使用 which 命令
         const whereCmd = process.platform === 'win32' ? 'where' : 'which';
-        const childProcess = spawn(whereCmd, [command]);
+        const childProcess = spawn(whereCmd, [command], { stdio: 'pipe' });
         childProcess.on('close', (code) => {
             resolve(code === 0);
         });
+        childProcess.on('error', () => {
+            resolve(false);
+        });
     });
 };
 
 /**
- * 使用指定工具打开当前目录
- * @param {string} tool 工具命令
+ * 使用 spawn 方式打开目录
+ * @param {string} command 命令
+ * @param {string} targetDir 目标目录
  */
-const _openWithTool = async (tool) => {
+const _openWithSpawn = async (command, targetDir) => {
     return new Promise((resolve, reject) => {
-        // 使用工具命令打开当前目录
-        const child = spawn(tool, ['.'], {
+        const child = spawn(command, [targetDir], {
             stdio: 'inherit',
-            cwd: process.cwd()
+            detached: true
         });
 
-        child.on('close', (code) => {
-            if (code === 0) {
-                Ec.info(`✅ 项目已成功在 ${tool} 中打开`);
-                resolve();
-            } else {
-                Ec.error(`❌ ${tool} 执行失败，退出码: ${code}`);
-                reject(new Error(`${tool} 执行失败，退出码: ${code}`));
-            }
-        });
+        // 分离子进程，让它独立运行
+        child.unref();
+
+        // 给一点时间让进程启动
+        setTimeout(() => {
+            resolve();
+        }, 500);
 
         child.on('error', (error) => {
             if (error.code === 'ENOENT') {
-                Ec.error(`❌ 未找到命令: ${tool}，请确保已正确安装`);
-                if (process.platform === 'win32') {
-                    Ec.waiting('💡 Windows 用户提示: 请确保工具已正确安装并在 PATH 环境变量中');
-                }
-                reject(new Error(`未找到命令: ${tool}，请确保已正确安装`));
+                reject(new Error(`未找到命令: ${command}`));
             } else {
-                Ec.error(`❌ 执行 ${tool} 时发生错误: ${error.message}`);
                 reject(error);
             }
         });
     });
-};
+};
+
+/**
+ * 打开目录
+ * @param {Object} tool 工具配置
+ * @param {string} targetDir 目标目录
+ */
+const _openDirectory = async (tool, targetDir) => {
+    Ec.waiting(`🚀 正在使用 ${tool.name.cyan} 打开目录...`);
+    
+    switch (tool.openMethod) {
+        case 'spawn':
+        default:
+            await _openWithSpawn(tool.command, targetDir);
+            break;
+    }
+    
+    Ec.info(`✅ 已启动 ${tool.name}`);
+};
+
+module.exports = async (options) => {
+    try {
+        // 1. 解析目录参数
+        const dirArg = _parseDirArg();
+        let targetDir = dirArg ? path.resolve(dirArg) : process.cwd();
+        
+        // 验证目录是否存在
+        if (!fs.existsSync(targetDir)) {
+            Ec.error(`❌ 目录不存在: ${targetDir}`);
+            process.exit(1);
+        }
+        
+        if (!fs.statSync(targetDir).isDirectory()) {
+            Ec.error(`❌ 路径不是目录: ${targetDir}`);
+            process.exit(1);
+        }
+        
+        // 2. 检查可用工具
+        const availableTools = [];
+        
+        for (const tool of AI_TOOLS) {
+            if (await _isCommandAvailable(tool.command)) {
+                availableTools.push(tool);
+            }
+        }
+        
+        if (availableTools.length === 0) {
+            Ec.error('❌ 未找到可用的 AI 工具');
+            console.log('');
+            console.log('  支持的工具:'.gray);
+            AI_TOOLS.forEach(tool => {
+                console.log(`    - ${tool.name}: ${tool.description}`.gray);
+            });
+            process.exit(1);
+        }
+        
+        // 3. 显示目标目录
+        console.log('');
+        Ec.info(`📂 目标目录: ${targetDir.cyan}`);
+        console.log('');
+        
+        // 4. 交互式选择工具
+        const menuItems = availableTools.map(tool => ({
+            name: tool.name,
+            description: tool.description,
+            _tool: tool
+        }));
+        
+        const selected = await selectSingle(menuItems, '选择 AI 工具');
+        
+        if (!selected) {
+            Ec.waiting('已取消');
+            process.exit(0);
+        }
+        
+        // 5. 打开目录
+        await _openDirectory(selected._tool, targetDir);
+        
+        process.exit(0);
+        
+    } catch (error) {
+        Ec.error(`❌ 执行失败: ${error.message}`);
+        process.exit(1);
+    }
+};