momo-ai 1.0.4 → 1.0.6

package/src/executor/executeAgentCfg.js

@@ -0,0 +1,195 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const Ec = require('../epic');
+
+/**
+ * 获取所有 agents 信息
+ * @returns {Array} agents 信息数组
+ */
+const _getAgents = () => {
+    const agentsDir = path.resolve(__dirname, '../_agent');
+    const agents = [];
+    
+    if (!fs.existsSync(agentsDir)) {
+        return agents;
+    }
+    
+    // 遍历 _agent 目录下的所有子目录
+    const types = fs.readdirSync(agentsDir).filter(file => 
+        fs.statSync(path.join(agentsDir, file)).isDirectory()
+    );
+    
+    // 遍历每个类型目录
+    types.forEach(type => {
+        const typeDir = path.join(agentsDir, type);
+        const files = fs.readdirSync(typeDir).filter(file => file.endsWith('.json'));
+        
+        // 遍历每个 json 文件
+        files.forEach(file => {
+            try {
+                const filePath = path.join(typeDir, file);
+                const content = fs.readFileSync(filePath, 'utf8');
+                const agentInfo = JSON.parse(content);
+                
+                agents.push({
+                    argName: file.replace('momo-', '').replace('.json', ''),
+                    type: type,
+                    name: agentInfo.name,
+                    id: agentInfo.id,
+                    uri: agentInfo.uri,
+                    filePath: filePath
+                });
+            } catch (error) {
+                Ec.waiting(`⚠️ 无法解析文件: ${file} - ${error.message}`);
+            }
+        });
+    });
+    
+    return agents;
+};
+
+/**
+ * 显示 agents 表格
+ * @param {Array} agents agents 信息数组
+ */
+const _showAgents = (agents) => {
+    if (agents.length === 0) {
+        Ec.waiting('未找到任何 agents');
+        return;
+    }
+    
+    // 计算列宽
+    const columnWidth = 20;
+    const uriColumnWidth = 30;
+    
+    // 表头
+    const header = "编号".padEnd(6) + 
+                  "Arg Name".padEnd(columnWidth) + 
+                  "Type".padEnd(columnWidth) + 
+                  "ID".padEnd(columnWidth) + 
+                  "URI".padEnd(uriColumnWidth) + 
+                  "Name";
+    Ec.waiting(header);
+    
+    // 分隔线
+    const separator = "-".repeat(5) + " " +
+                     "-".repeat(columnWidth - 1) + " " +
+                     "-".repeat(columnWidth - 1) + " " +
+                     "-".repeat(columnWidth - 1) + " " +
+                     "-".repeat(uriColumnWidth - 1) + " " +
+                     "-".repeat(columnWidth - 1);
+    Ec.waiting(separator);
+    
+    // 数据行
+    agents.forEach((agent, index) => {
+        const row = `${(index + 1).toString().padEnd(6)}` +
+                   `${agent.argName.padEnd(columnWidth).red.bold}` +
+                   `${agent.type.padEnd(columnWidth)}` +
+                   `${agent.id.padEnd(columnWidth)}` +
+                   `${agent.uri.padEnd(uriColumnWidth)}` +
+                   agent.name;
+        Ec.waiting(row);
+    });
+    
+    Ec.waiting(separator);
+    Ec.waiting(`${(agents.length + 1).toString().padEnd(6)}退出`);
+    Ec.waiting('');
+};
+
+/**
+ * 在浏览器中打开 URI
+ * @param {string} uri 要打开的 URI
+ * @param {string} agentType agent 类型
+ */
+const _openInBrowser = (uri, agentType) => {
+    Ec.waiting(`🚀 正在打开 ${agentType} 中的 agent...`);
+    
+    let command;
+    switch (process.platform) {
+        case 'darwin': // macOS
+            command = `open "${uri}"`;
+            break;
+        case 'win32': // Windows
+            command = `start "" "${uri}"`;
+            break;
+        default: // Linux
+            command = `xdg-open "${uri}"`;
+            break;
+    }
+    
+    const child = spawn(command, { shell: true });
+    
+    child.on('error', (error) => {
+        Ec.waiting(`⚠️ 无法打开浏览器: ${error.message}`);
+    });
+    
+    child.on('close', (code) => {
+        if (code === 0) {
+            Ec.waiting(`✅ 浏览器已打开，请确保您的 IDE 已启动`);
+        } else {
+            Ec.waiting(`⚠️ 浏览器打开失败，退出码: ${code}`);
+        }
+    });
+};
+
+/**
+ * 交互式选择 agents
+ * @param {Array} agents agents 信息数组
+ */
+const _interactiveSelect = async (agents) => {
+    while (true) {
+        _showAgents(agents);
+        Ec.waiting('💡 提示: 请确保您的 IDE 已启动，以便正确配置 agent');
+        const answer = await Ec.ask('请输入编号选择 agent (或输入退出编号): ');
+        
+        const selectedIndex = parseInt(answer) - 1;
+        
+        // 检查是否选择退出
+        if (selectedIndex === agents.length) {
+            Ec.waiting('👋 再见!');
+            break;
+        }
+        
+        // 检查选择是否有效
+        if (isNaN(selectedIndex) || selectedIndex < 0 || selectedIndex >= agents.length) {
+            Ec.waiting('❌ 无效的选择，请重新输入');
+            continue;
+        }
+        
+        // 打开选中的 agent
+        const selectedAgent = agents[selectedIndex];
+        _openInBrowser(selectedAgent.uri, selectedAgent.type);
+        
+        // 等待一段时间让用户看到结果
+        await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+};
+
+module.exports = async () => {
+    try {
+        Ec.waiting('🔍 正在枚举所有可用的 agents...');
+        
+        // 获取所有 agents
+        const agents = _getAgents();
+        
+        if (agents.length === 0) {
+            Ec.waiting('❌ 未找到任何 agents');
+            Ec.askClose();
+            process.exit(0);
+        }
+        
+        Ec.waiting(`✅ 找到 ${agents.length} 个 agents`);
+        Ec.waiting('');
+        
+        // 进入交互式选择
+        await _interactiveSelect(agents);
+        
+        Ec.askClose();
+        process.exit(0);
+    } catch (error) {
+        Ec.error(`执行过程中发生错误: ${error.message}`);
+        Ec.askClose();
+        process.exit(1);
+    }
+};

package/src/executor/executeInit.js

@@ -133,6 +133,8 @@ const _ioFile = async (baseDir) => {
         ".momo/prompt/",
         ".momo/template/",
         ".momo/scripts/",
+        "reference/maven",
+        "reference/npm",
         "specification/changes/",
         "specification/actor/",
         "specification/.archives/",
@@ -255,7 +257,9 @@ const _ioFile = async (baseDir) => {
  * .momo/advanced/                              高级配置说明
  *               /actor.md                       - 角色定制说明
  * .momo/scripts/                               特殊脚本目录
- *
+ * reference/
+ *          /maven/                             Maven 外置项目
+ *          /npm/                               NPM 外置项目
  * specification/                               工作目录
  *              /project.md                      - 项目基本说明文件
  *              /project-model.md                - 模型说明文件（通常是建模所需的核心概念模型）

package/src/executor/executeOpen.js

@@ -1,19 +1,19 @@
 const Ec = require('../epic');
-const { spawn } = require('child_process');
+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' }
+            {name: 'Trae', command: 'trae'},
+            {name: 'Cursor', command: 'cursor'},
+            {name: 'Lingma', command: 'lingma'},
+            {name: 'Kiro', command: 'kiro'}
         ];
-        
+
         // 检查哪些工具可用
         const availableTools = [];
         for (const tool of aiTools) {
@@ -21,14 +21,14 @@ module.exports = async (options) => {
                 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];
@@ -45,7 +45,7 @@ module.exports = async (options) => {
             Ec.askClose();
             process.exit(0);
         }
-        
+
         // 显示交互式选择菜单
         Ec.waiting('🔍 检测到多个可用的AI工具，请选择要使用的工具:');
         const choices = availableTools.map((tool, index) => {
@@ -59,18 +59,18 @@ module.exports = async (options) => {
                 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;
-        
+
         // 检查用户选择
         if (isNaN(selectedIndex) || selectedIndex < 0 || selectedIndex >= availableTools.length) {
             if (selectedIndex === availableTools.length) {
@@ -82,7 +82,7 @@ module.exports = async (options) => {
             Ec.askClose();
             process.exit(1);
         }
-        
+
         // 执行选择的工具
         const selectedTool = availableTools[selectedIndex];
         let toolDisplayName = selectedTool.name;
@@ -93,8 +93,9 @@ module.exports = async (options) => {
         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 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
@@ -113,8 +114,8 @@ const _isCommandAvailable = async (command) => {
     return new Promise((resolve) => {
         // 在 Windows 上使用 where 命令，在其他系统上使用 which 命令
         const whereCmd = process.platform === 'win32' ? 'where' : 'which';
-        const process = spawn(whereCmd, [command]);
-        process.on('close', (code) => {
+        const childProcess = spawn(whereCmd, [command]);
+        childProcess.on('close', (code) => {
             resolve(code === 0);
         });
     });
@@ -127,11 +128,11 @@ const _isCommandAvailable = async (command) => {
 const _openWithTool = async (tool) => {
     return new Promise((resolve, reject) => {
         // 使用工具命令打开当前目录
-        const child = spawn(tool, ['.'], { 
+        const child = spawn(tool, ['.'], {
             stdio: 'inherit',
             cwd: process.cwd()
         });
-        
+
         child.on('close', (code) => {
             if (code === 0) {
                 Ec.info(`✅ 项目已成功在 ${tool} 中打开`);
@@ -141,7 +142,7 @@ const _openWithTool = async (tool) => {
                 reject(new Error(`${tool} 执行失败，退出码: ${code}`));
             }
         });
-        
+
         child.on('error', (error) => {
             if (error.code === 'ENOENT') {
                 Ec.error(`❌ 未找到命令: ${tool}，请确保已正确安装`);

package/src/executor/executePlan.js

@@ -1,8 +1,8 @@
 const fs = require('fs');
 const path = require('path');
-const { spawn } = require('child_process');
 const Ec = require('../epic');
 const fsAsync = require('fs').promises;
+const { outCopy } = require('../epic/momo.fn.out');
 
 /**
  * 读取模板文件并提取 <!-- BEGIN --> 到 <!-- END --> 之间的内容
@@ -75,21 +75,8 @@ const _copyToClipboard = async (content, requirementName) => {
         // 去除换行符，将内容合并为一行
         const contentWithoutNewlines = content.replace(/\r?\n|\r/g, ' ');
         
-        // 根据操作系统选择合适的剪贴板命令
-        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();
+        // 使用统一的剪贴板函数
+        await outCopy(contentWithoutNewlines);
         Ec.waiting('✅ 计划提示词已复制到剪贴板');
         
         // 保存内容到 .working 目录

package/src/executor/executeProject.js

@@ -0,0 +1,296 @@
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+const Ec = require('../epic');
+
+// 将 fs 方法转换为 Promise 版本
+const fsAsync = {
+    mkdir: util.promisify(fs.mkdir),
+    copyFile: util.promisify(fs.copyFile),
+    readdir: util.promisify(fs.readdir),
+    stat: util.promisify(fs.stat),
+    readFile: util.promisify(fs.readFile),
+    writeFile: util.promisify(fs.writeFile)
+};
+
+/**
+ * 获取或创建 refer.json 配置文件路径
+ * @param {string} baseDir 项目根目录
+ * @returns {string} refer.json 文件路径
+ */
+const _getReferConfigPath = (baseDir) => {
+    return path.resolve(baseDir, '.momo', 'advanced', 'refer.json');
+};
+
+/**
+ * 获取默认的 refer 配置
+ * @returns {Object} 默认配置对象
+ */
+const _getDefaultReferConfig = () => {
+    return {
+        maven: {
+            file: 'pom.xml',
+            target: 'reference/maven'
+        },
+        gradle: {
+            file: 'build.gradle',
+            target: 'reference/gradle'
+        },
+        npm: {
+            file: 'package.json',
+            target: 'reference/npm'
+        },
+        rust: {
+            file: 'Cargo.toml',
+            target: 'reference/rust'
+        },
+        go: {
+            file: 'go.mod',
+            target: 'reference/go'
+        },
+        ruby: {
+            file: 'Gemfile',
+            target: 'reference/ruby'
+        },
+        python: {
+            file: 'requirements.txt',
+            target: 'reference/python'
+        },
+        php: {
+            file: 'composer.json',
+            target: 'reference/php'
+        },
+        dotnet: {
+            file: 'project.csproj',
+            target: 'reference/dotnet'
+        },
+        java: {
+            file: 'pom.xml',
+            target: 'reference/java'
+        },
+        cmake: {
+            file: 'CMakeLists.txt',
+            target: 'reference/cmake'
+        },
+        make: {
+            file: 'Makefile',
+            target: 'reference/make'
+        }
+    };
+};
+
+/**
+ * 读取或创建 refer.json 配置文件
+ * @param {string} configPath 配置文件路径
+ * @returns {Promise<Object>} 配置对象
+ */
+const _readOrCreateReferConfig = async (configPath) => {
+    // 确保 .momo/advanced 目录存在
+    const configDir = path.dirname(configPath);
+    if (!fs.existsSync(configDir)) {
+        await fsAsync.mkdir(configDir, { recursive: true });
+    }
+
+    const defaultConfig = _getDefaultReferConfig();
+    
+    // 如果配置文件不存在，创建默认配置
+    if (!fs.existsSync(configPath)) {
+        await fsAsync.writeFile(configPath, JSON.stringify(defaultConfig, null, 4));
+        Ec.waiting(`创建默认配置文件: ${path.relative(process.cwd(), configPath)}`);
+        return defaultConfig;
+    }
+
+    // 读取现有配置
+    try {
+        const content = await fsAsync.readFile(configPath, 'utf8');
+        const existingConfig = JSON.parse(content);
+        
+        // 检查是否需要更新配置（添加新的项目类型）
+        let updated = false;
+        for (const [key, value] of Object.entries(defaultConfig)) {
+            if (!existingConfig[key]) {
+                existingConfig[key] = value;
+                updated = true;
+            }
+        }
+        
+        // 如果有更新，则写回文件
+        if (updated) {
+            await fsAsync.writeFile(configPath, JSON.stringify(existingConfig, null, 4));
+            Ec.waiting(`更新配置文件: ${path.relative(process.cwd(), configPath)}`);
+        }
+        
+        return existingConfig;
+    } catch (error) {
+        Ec.error(`配置文件格式错误: ${configPath}`);
+        throw error;
+    }
+};
+
+/**
+ * 显示当前支持的项目类型（表格形式）
+ * @param {Object} referConfig 引用配置
+ */
+const _showSupportedTypes = (referConfig) => {
+    Ec.waiting("当前支持的项目类型:");
+    
+    // 定义列宽
+    const columnWidth = 24;
+    
+    // 表头
+    const header = "Type".padEnd(columnWidth) + 
+                  "ID File".padEnd(columnWidth) + 
+                  "Store Path";
+    Ec.waiting(header);
+    
+    // 分隔线
+    const separator = "-".repeat(columnWidth - 1) + " " +
+                     "-".repeat(columnWidth - 1) + " " +
+                     "-".repeat(columnWidth - 1);
+    Ec.waiting(separator);
+    
+    // 数据行
+    for (const [type, config] of Object.entries(referConfig)) {
+        const row = type.padEnd(columnWidth) + 
+                   config.file.padEnd(columnWidth) + 
+                   config.target;
+        Ec.waiting(row);
+    }
+    
+    Ec.info("使用方法: momo project -s \"项目路径\"");
+};
+
+/**
+ * 检查路径是否为目录
+ * @param {string} sourcePath 路径
+ * @returns {Promise<boolean>} 是否为目录
+ */
+const _isDirectory = async (sourcePath) => {
+    try {
+        const stats = await fsAsync.stat(sourcePath);
+        return stats.isDirectory();
+    } catch (error) {
+        return false;
+    }
+};
+
+/**
+ * 检查目录中是否存在指定文件
+ * @param {string} sourceDir 源目录
+ * @param {string} fileName 文件名
+ * @returns {Promise<boolean>} 是否存在文件
+ */
+const _hasFile = async (sourceDir, fileName) => {
+    try {
+        const filePath = path.join(sourceDir, fileName);
+        const stats = await fsAsync.stat(filePath);
+        return stats.isFile();
+    } catch (error) {
+        return false;
+    }
+};
+
+/**
+ * 递归拷贝目录
+ * @param {string} src 源目录
+ * @param {string} dest 目标目录
+ */
+const _copyDir = async (src, dest) => {
+    const entries = await fsAsync.readdir(src, { withFileTypes: true });
+    await fsAsync.mkdir(dest, { recursive: true });
+
+    for (let entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+
+        if (entry.isDirectory()) {
+            await _copyDir(srcPath, destPath);
+        } else {
+            await fsAsync.copyFile(srcPath, destPath);
+        }
+    }
+};
+
+/**
+ * 处理项目引用
+ * @param {string} sourcePath 源项目路径
+ * @param {Object} referConfig 引用配置
+ * @param {string} baseDir 项目根目录
+ */
+const _processProjectReference = async (sourcePath, referConfig, baseDir) => {
+    // 检查源路径是否为目录
+    if (!(await _isDirectory(sourcePath))) {
+        Ec.error(`源路径必须是一个目录: ${sourcePath}`);
+        process.exit(1);
+    }
+
+    Ec.waiting(`检查项目: ${sourcePath}`);
+
+    // 遍历配置中的每种项目类型
+    for (const [type, config] of Object.entries(referConfig)) {
+        const { file, target } = config;
+        
+        // 检查源目录中是否存在指定文件
+        if (await _hasFile(sourcePath, file)) {
+            Ec.waiting(`检测到 ${type} 项目 (${file})`);
+
+            // 构建目标目录路径
+            const targetDir = path.resolve(baseDir, target);
+            
+            // 确保目标目录存在
+            if (!fs.existsSync(targetDir)) {
+                Ec.waiting(`创建目录: ${target}`);
+                await fsAsync.mkdir(targetDir, { recursive: true });
+            }
+
+            // 生成目标子目录名称（使用源目录名称）
+            const sourceDirName = path.basename(sourcePath);
+            const finalTargetDir = path.join(targetDir, sourceDirName);
+
+            // 拷贝项目
+            try {
+                Ec.waiting(`拷贝项目到: ${path.join(target, sourceDirName)}`);
+                await _copyDir(sourcePath, finalTargetDir);
+                Ec.waiting(`✅ ${type} 项目引用成功`);
+            } catch (error) {
+                Ec.error(`❌ 拷贝项目失败: ${error.message}`);
+                throw error;
+            }
+        }
+    }
+};
+
+module.exports = async (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+    const sourcePath = parsed.source;
+
+    try {
+        // 获取项目根目录
+        const baseDir = process.cwd();
+
+        // 获取 refer.json 配置文件路径
+        const configPath = _getReferConfigPath(baseDir);
+
+        // 读取或创建配置文件
+        const referConfig = await _readOrCreateReferConfig(configPath);
+        
+        // 如果没有提供 source 参数，则显示支持的项目类型
+        if (!sourcePath) {
+            _showSupportedTypes(referConfig);
+            Ec.askClose();
+            process.exit(0);
+        }
+
+        // 处理项目引用
+        await _processProjectReference(sourcePath, referConfig, baseDir);
+
+        Ec.info("项目引用处理完成！");
+        Ec.askClose();
+        process.exit(0);
+    } catch (error) {
+        Ec.error(`执行过程中发生错误: ${error.message}`);
+        Ec.askClose();
+        process.exit(1);
+    }
+};