momo-ai 1.0.5 → 1.0.6

package/.momo/advanced/refer.json

@@ -0,0 +1,50 @@
+{
+    "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"
+    }
+}

package/README.md

@@ -5,6 +5,8 @@
 
 ## 1. 介绍
 
+### 1.1. 功能说明
+
 当前工具会在操作系统中安装 `momo` 命令，使用它进行 `SDD - Spec Driven Development` 开发：
 
 1. 参考：`OpenSpec / Spec-Kit / Kiro`
@@ -22,6 +24,30 @@
 
 > 除开 `momo` 命令后续会提供和模型直接交互的 `lain` 命令，近似 `iFlow / openspec` 的功能。
 
+### 1.2. 开始步骤
+
+1. 使用 `momo init` 初始化协同工程项目（运行之前可使用 `momo env` 检查环境）。
+2. 使用 `momo repo` 添加项目代码库以及工程实例（有多少个 `Agent` 工作就添加多少工程实例），添加完成后可使用 `momo open`
+   直接打开工程。
+3. 更新 `project.md / project-model.md / requirement.md` 的细节文档（可用AI帮助拆分和书写）
+4. 使用 `momo add -n 需求名称` 添加细节需求（可用AI帮助拆分和书写：`momo plan -n 需求名称`）
+5. 使用 `momo tasks` 列出所有任务，并且使用 `momo run` 运行任务得到任务提示词
+
+> 带 (CV) 📋️ 标记的命令——运行成功后可直接“Ctrl + V”粘贴到 TRAE / Lingma / Cursor / Kiro 中执行。
+
+### 1.3. 项目计划
+
+1. 使用 `momo project` 将后端项目拷贝到 `reference` 目录中（主要是提供数据模型）。
+2. （唯一的人工处理）更新 `project.md` 中的所有信息，核心包括：
+    - 功能描述
+    - 场景描述等
+    - 风格
+    - 技术栈
+3. 使用 `momo agentcfg` 给 TRAE 工具配置智能体，主要是导入部分已经定制好的智能体。
+4. 使用 `momo agent -a "智能体名称"` 调用智能体进行开发之前的准备工作，目前支持的智能体可直接使用 `momo agentcfg` 查看。
+
+<hr/>
+
 ## 2. 工具使用
 
 ### 2.1. 安装
@@ -32,67 +58,55 @@ npm install -g momo-ai
 momo help
 ```
 
-### 2.2. 操作步骤
-
-1. 使用 `momo init` 初始化协同工程项目（运行之前可使用 `momo env` 检查环境）。
-2. 使用 `momo repo` 添加项目代码库以及工程实例（有多少个 `Agent` 工作就添加多少工程实例），添加完成后可使用 `momo open`
-   直接打开工程。
-3. 更新 `project.md / project-model.md / requirement.md` 的细节文档（可用AI帮助拆分和书写）
-4. 使用 `momo add -n 需求名称` 添加细节需求（可用AI帮助拆分和书写：`momo plan -n 需求名称`）
-5. 使用 `momo tasks` 列出所有任务，并且使用 `momo run` 运行任务得到任务提示词
-
-> 带 (CV) 标记的命令运行成功后可直接“Ctrl + V”粘贴到 TRAE / Lingma / Cursor / Kiro 中执行。
-
 ### 2.3. 命令：不定模型
 
 ```bash
 # ------------ 工程初始化 -----------------
-# 检查环境相关信息
-momo env                    # 环境检查
+# 🌷 环境检查、工程和代码初始化、工具启动等
+momo env                            # 环境检查
 
-# momo init
-momo init -d app-fly        # 初始化 directory = app-fly 的项目
-momo init                   # 初始化当前项目
+momo init -d app-fly                # 初始化 directory = app-fly 的项目
+momo init                           # 初始化当前项目
 
-# momo repo 
 momo repo -a https://xxx/repo.git   # 克隆远程代码库 -> source/repo/develop-01（名称靠解析） -> git submodule
 momo repo -a xxx -i 10              # 克隆远程代码库（10个副本）
 
 momo open                           # 交互式使用 TRAE / Lingma / Cursor / Kiro 打开当前项目
 
-# ------------ 需求管理 -----------------
-# momo add
-momo add -n "需求名称"               # 添加新需求 -> changes 下追加新内容 -> 包括任务
-momo add -n "需求 md 文档路径"        # 添加需求文档 -> changes 下追加新内容 -> 包括任务，如果带后缀直接用文件名做需求名称
+momo project -s "项目路径"           # 将路径中的显示拷贝到当前项目的 reference 目录下，若不提供 -s 则直接列举所有支持的项目类型
+
+momo agentcfg                       # 列出所有智能体，并且打开浏览器配置
+momo agent -a "智能体名称"           # 📋️ 调用智能体 -> prompt 得到提示词到剪切板
 
-# momo plan               
-momo plan -n "需求名称"              # 生成需求的整体开发计划 -> prompt 剪切板
+# ------------ 需求相关 -----------------
+# 🌷 需求管理：添加、归档、校验、列出、显示
+momo add -n "需求名称"               # 📋️ 添加新需求 -> changes 下追加新内容 -> 包括任务
+momo add -n "需求(MD)文档路径"        # 📋️ 添加需求文档 -> changes 下追加新内容 -> 包括任务，如果带后缀直接用文件名做需求名称
 
-# momo archive
 momo archive -n "需求名称"           # 需求归档 -> archive 下追加新内容，删除 changes 下内容
 
-# momo show
 momo show -n "需求名称"              # 显示需求 -> 显示 changes 下内容
 
-# momo validate
 momo validate -n "需求名称"          # 需求校验 -> 校验 changes 下内容
 
-# momo list
 momo list                           # 列出所有需求 -> changes 下内容
 
-# ------------ 任务执行 -----------------
-# momo tasks
-momo tasks                          # 显示任务 -> 需求 / 任务 / 状态 -> 状态 = 待办 / 进行中 / 已完成
 
-# momo actors
+# 🌷 需求分析：计划、执行、拆分
+momo plan -n "需求名称"              # 📋️ 生成需求的整体开发计划 -> prompt 剪切板
+
+# ------------ 任务执行 -----------------
+# 🌷 任务执行：定义角色、执行任务
 momo actors                         # 列出所有角色
 
-# momo actor                        
 momo actor -a "角色名称"             # 添加新角色 -> 交互式命令，每个角色可以指定不同的大模型
 
-# momo run                          ( 生成提示词 -> 剪切板，自动计算空闲的 source-01 ）
-momo run -a {actor} -t {task}       # 将任务分配给角色，检查执行目录看哪些任务正在执行
-momo run                            # 从菜单中选择任务
+
+momo tasks                          # 📋️ 显示任务 -> 需求 / 任务 / 状态 -> 状态 = 待办 / 进行中 / 已完成
+
+momo run -a {actor} -t {task}       # 📋️ 将任务分配给角色，检查执行目录看哪些任务正在执行
+momo run                            # 📋️ 从菜单中选择任务
+
 momo unlock                         # 解锁任务 -> 任务状态 = 待办
 ```
 
@@ -100,6 +114,8 @@ momo unlock                         # 解锁任务 -> 任务状态 = 待办
 
 > 控制台开发中（Lain 模式）
 
+<hr/>
+
 ## 3. 参考链接
 
 ### 3.1. 旧版

package/package.json

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

package/src/_agent/trae/momo-datamodel.json

@@ -0,0 +1,5 @@
+{
+    "name": "领域建模师",
+    "id": "momo-datamodel",
+    "uri": "https://s.trae.ai/a/a9dcaa"
+}

package/src/_agent/trae/momo-module-req.json

@@ -0,0 +1,5 @@
+{
+    "name": "模块需求分析师",
+    "id": "momo-module-req",
+    "uri": "https://s.trae.ai/a/c4fc46"
+}

package/src/_agent/trae/momo-system-req.json

@@ -0,0 +1,5 @@
+{
+    "name": "系统需求分析师",
+    "id": "momo-system-req",
+    "uri": "https://s.trae.ai/a/d0c6b9"
+}

package/src/_agent/trae/momo-task.json

@@ -0,0 +1,5 @@
+{
+    "name": "任务规划师",
+    "id": "momo-task",
+    "uri": "https://s.trae.ai/a/1fdc4e"
+}

package/src/_template/PROMPT/plan.md.ejs

@@ -1,4 +1,4 @@
-# 添加需求提示词
+# 需求计划提示词
 
 <!-- BEGIN -->
 阅读 specification/project.md 中的基本需求信息，根据 <%= NAME %> 的描述信息，重新制定需求的开发计划，更改掉 specification/changes/<%= NAME %>/ 目录中的需求说明，重新制定任务清单并且更新（子任务清单在specification/changes/<%= NAME %>/tasks/目录下），项目本身的技术栈和数据模型可参考 specification/project-model.md 文件。

package/src/_template/PROMPT/trae/momo-datamodel.ejs

@@ -0,0 +1,8 @@
+# 领域建模提示词
+
+<!-- BEGIN -->
+分析 reference/ 下的项目，查找对应的数据模型，根据查找的数据模型更新  specification/project-model.md 文档作为当前项目所需的领域模型核心文档
+
+1. 主要分析实体模型、关系模型、常量和枚举等。
+2. 若分析过程中出现了多种不同的项目则让我选择用哪种项目做初始分析。
+<!-- END -->

package/src/_template/PROMPT/trae/momo-module-req.ejs

@@ -0,0 +1,11 @@
+# 模块需求提示词
+
+<!-- BEGIN -->
+详细解读 specification/requirement.md 需求文档中的模块和每个模块的功能列表，在 specification/changes/ 目录之下创建模块的核心文档，每个模块用 MXX- 前缀，其中 XX 是模块编号。
+
+1. 每个模块中包括 tasks/ 目录、任务明细文档存放位置。
+2. 每个模块中包括 proposal.md，此文档中用来存放模块的详细需求。
+3. 每个模块中包括 tasks.md，此文档中是描述所有任务的总清单。
+4. 模块所需的数据模型可参考 specification/project-model.md 文档。
+5. 有多少模块在于你的模块的整体设计，记得模块内部业务要形成完整闭环。
+<!-- END -->

package/src/_template/PROMPT/trae/momo-system-req.ejs

@@ -0,0 +1,9 @@
+# 系统需求提示词
+
+<!-- BEGIN -->
+根据人工提供的 specification/project.md 的详细需求描述进行核心分析，生成一份当前项目的比较规范的需求描述文档，用文档更新 specification/requirement.md 文档，这份需求文档的读者是前端架构师和前端工程师，所以一定要阐述清楚整个系统实现想要达到的效果和功能
+
+1. 数据模型可以参考 specification/project-model.md 文档。
+2. 技术栈信息可以直接从 specification/project.md 需求文档中提取。
+3. 输出文档中一定要输出的核心内容：模块清单、模块中的功能列表。
+<!-- END -->

package/src/_template/PROMPT/trae/momo-task.ejs

@@ -0,0 +1,11 @@
+# 领域建模提示词
+
+<!-- BEGIN -->
+解读 specification/changes/ 下的所有模块（必须是 MXX- 开头的目录）对应的变更内容，并生成领域模型，根据每个目录中的 tasks.md 生成对应的任务并且更新 tasks.md 文件：
+
+1. 每个模块的详细需求位于 specification/changes/MXX-模块/proposal.md 文件中。
+2. 每个任务存放在 specification/changes/MXX-模块/tasks/ 目录下。
+3. 任务文件名统一成 MXX-TNNN.md，其中 NN 是任务编号，NNN 是任务编号，编号长度不足用 0 填充。
+4. 每个任务文件中要写出任务实施过程的详细步骤。
+5. 系统相关的数据模型参考 specification/data-model.md 文件。
+<!-- END -->

package/src/commander/agent.json

@@ -0,0 +1,12 @@
+{
+    "executor": "executeAgent",
+    "description": "加载并复制指定 Agent 的提示词到剪切板",
+    "command": "agent",
+    "options": [
+        {
+            "name": "agent",
+            "alias": "a",
+            "description": "智能体名称（Arg Name）"
+        }
+    ]
+}

package/src/commander/agentcfg.json

@@ -0,0 +1,5 @@
+{
+    "executor": "executeAgentCfg",
+    "description": "配置和打开系统内置 agents",
+    "command": "agentcfg"
+}

package/src/commander/project.json

@@ -0,0 +1,12 @@
+{
+    "executor": "executeProject",
+    "description": "引用外部项目到 reference 目录中",
+    "command": "project",
+    "options": [
+        {
+            "name": "source",
+            "alias": "s",
+            "description": "项目路径，必须提供"
+        }
+    ]
+}

package/src/executor/executeAgent.js

@@ -0,0 +1,214 @@
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+const Ec = require('../epic');
+
+// 将 fs 方法转换为 Promise 版本
+const fsAsync = {
+    readFile: util.promisify(fs.readFile),
+    readdir: util.promisify(fs.readdir),
+    stat: util.promisify(fs.stat)
+};
+
+/**
+ * 获取所有 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,
+                    id: agentInfo.id,
+                    name: agentInfo.name,
+                    uri: agentInfo.uri,
+                    filePath: filePath
+                });
+            } catch (error) {
+                Ec.waiting(`⚠️ 无法解析文件: ${file} - ${error.message}`);
+            }
+        });
+    });
+    
+    return agents;
+};
+
+/**
+ * 从 EJS 模板中提取内容
+ * @param {string} templatePath 模板路径
+ * @returns {Promise<string>} 提取的模板内容
+ */
+const _extractTemplateContent = async (templatePath) => {
+    try {
+        const content = await fsAsync.readFile(templatePath, 'utf8');
+        const lines = content.split('\n');
+        let beginIndex = -1;
+        let endIndex = -1;
+        
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes('<!-- BEGIN -->')) {
+                beginIndex = i;
+            } else if (lines[i].includes('<!-- END -->')) {
+                endIndex = i;
+                break;
+            }
+        }
+        
+        if (beginIndex !== -1 && endIndex !== -1) {
+            // 提取 BEGIN 和 END 之间的内容（不包括 BEGIN 和 END 行）
+            return lines.slice(beginIndex + 1, endIndex).join('\n');
+        }
+        
+        return content;
+    } catch (error) {
+        throw new Error(`无法读取模板文件: ${error.message}`);
+    }
+};
+
+/**
+ * 将内容复制到剪贴板
+ * @param {string} content 要复制的内容
+ */
+const _copyToClipboard = async (content) => {
+    const { outCopy } = require('../epic/momo.fn.out');
+    try {
+        // 先打印内容，按行打印并保留前缀
+        Ec.waiting('📄 提示词内容:');
+        Ec.waiting('----------------------------------------');
+        const lines = content.split('\n');
+        lines.forEach(line => {
+            Ec.waiting(line);
+        });
+        Ec.waiting('----------------------------------------');
+        
+        // 再复制到剪贴板
+        await outCopy(content);
+        Ec.waiting('✅ 提示词已复制到剪贴板');
+    } catch (error) {
+        Ec.waiting(`复制到剪贴板失败: ${error.message}`);
+        // 提供备选方案
+        Ec.waiting('提示词内容:');
+        const lines = content.split('\n');
+        lines.forEach(line => {
+            Ec.waiting(line);
+        });
+    }
+};
+
+module.exports = async (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+    const agentName = parsed.agent || parsed.a;
+
+    try {
+        // 获取所有 agents
+        const agents = _getAgents();
+        
+        if (agents.length === 0) {
+            Ec.error("❌ 未找到任何 agents");
+            Ec.askClose();
+            process.exit(1);
+        }
+        
+        // 如果没有提供 agent 参数，显示可用的 agents 并让用户选择
+        if (!agentName) {
+            Ec.waiting('可用的 Agents:');
+            agents.forEach((agent, index) => {
+                Ec.waiting(`${index + 1}. ${agent.argName.red.bold} (${agent.name}), id = ${agent.id}, uri = ${agent.uri}`);
+            });
+            
+            // 获取用户选择
+            const answer = await Ec.ask('请选择要使用的 Agent (输入编号): ');
+            const selectedIndex = parseInt(answer) - 1;
+            
+            // 验证选择
+            if (isNaN(selectedIndex) || selectedIndex < 0 || selectedIndex >= agents.length) {
+                Ec.error("❌ 无效的选择");
+                Ec.askClose();
+                process.exit(1);
+            }
+            
+            // 使用选择的 agent
+            const selectedAgent = agents[selectedIndex];
+            return await _processAgent(selectedAgent);
+        }
+        
+        // 查找指定的 agent
+        const agent = agents.find(a => a.argName === agentName);
+        if (!agent) {
+            Ec.error(`❌ 未找到名为 "${agentName}" 的 Agent`);
+            Ec.waiting('可用的 Agents:');
+            agents.forEach((a, index) => {
+                Ec.waiting(`${index + 1}. ${a.argName.red.bold} (${a.name}), id = ${a.id}, uri = ${a.uri}`);
+            });
+            Ec.askClose();
+            process.exit(1);
+        }
+        
+        // 处理选中的 agent
+        await _processAgent(agent);
+        
+    } catch (error) {
+        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        Ec.askClose();
+        process.exit(1);
+    }
+};
+
+/**
+ * 处理选中的 agent
+ * @param {Object} agent 选中的 agent 对象
+ */
+const _processAgent = async (agent) => {
+    try {
+        // 构建模板路径
+        const templatePath = path.resolve(__dirname, `../_template/PROMPT/${agent.type}/${agent.id}.ejs`);
+        
+        // 检查模板文件是否存在
+        if (!fs.existsSync(templatePath)) {
+            Ec.error(`❌ 未找到模板文件: ${templatePath}`);
+            Ec.askClose();
+            process.exit(1);
+        }
+        
+        // 提取模板内容
+        const content = await _extractTemplateContent(templatePath);
+        
+        // 复制到剪贴板
+        await _copyToClipboard(content);
+        
+        // 显示警告提示
+        Ec.waiting('');
+        Ec.warn('⚠️  为了获得最佳效果，请在您的 IDE 工具窗口中选择对应的 Agent 来配合使用此提示词');
+        
+        Ec.askClose();
+        process.exit(0);
+    } catch (error) {
+        Ec.error(`❌ 处理 Agent 时发生错误: ${error.message}`);
+        Ec.askClose();
+        process.exit(1);
+    }
+};

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/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);
+    }
+};

package/src/executor/index.js

@@ -14,6 +14,10 @@ const executeActors = require('./executeActors');
 const executeRun = require('./executeRun');
 const executeTasks = require('./executeTasks');
 const executeUnlock = require('./executeUnlock');
+const executeProject = require('./executeProject');
+const executeAgentCfg = require('./executeAgentCfg');
+const executeAgent = require('./executeAgent');
+
 const exported = {
     executeHelp,
     executeInit,
@@ -30,6 +34,9 @@ const exported = {
     executeActors,
     executeRun,
     executeTasks,
-    executeUnlock
+    executeUnlock,
+    executeProject,
+    executeAgentCfg,
+    executeAgent
 };
 module.exports = exported;