momo-ai 1.0.0 → 1.0.2

package/src/executor/executeArchive.js

@@ -0,0 +1,124 @@
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+const Ec = require('../epic');
+const fsAsync = require('fs').promises;
+
+/**
+ * 检查需求目录是否存在
+ * @param {string} changesDir changes目录路径
+ * @param {string} requirementName 需求名称
+ * @returns {boolean} 是否存在
+ */
+const _isRequirementExists = (changesDir, requirementName) => {
+    const requirementDir = path.join(changesDir, requirementName);
+    return fs.existsSync(requirementDir);
+};
+
+/**
+ * 递归拷贝目录
+ * @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} dirPath 目录路径
+ */
+const _removeDir = async (dirPath) => {
+    const entries = await fsAsync.readdir(dirPath, { withFileTypes: true });
+    
+    for (let entry of entries) {
+        const entryPath = path.join(dirPath, entry.name);
+        
+        if (entry.isDirectory()) {
+            await _removeDir(entryPath);
+        } else {
+            await fsAsync.unlink(entryPath);
+        }
+    }
+    
+    await fsAsync.rmdir(dirPath);
+};
+
+module.exports = async (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+    
+    // 获取需求名称
+    const requirementName = parsed.name || parsed.n;
+    
+    // 验证参数
+    if (!requirementName) {
+        Ec.error("❌ 请提供需求名称 (-n, --name)");
+        process.exit(1);
+    }
+    
+    // 检查需求名称是否包含点号（扩展名）
+    if (requirementName.includes('.')) {
+        Ec.error("❌ 需求名称不能包含点号(.)，以防止与文件扩展名混淆");
+        process.exit(1);
+    }
+    
+    Ec.waiting(`准备归档需求: ${requirementName}`);
+    
+    try {
+        // 获取项目路径
+        const projectDir = process.cwd();
+        const changesDir = path.join(projectDir, 'specification', 'changes');
+        const archivesDir = path.join(projectDir, 'specification', '.archives');
+        
+        // 检查需求是否存在
+        if (!_isRequirementExists(changesDir, requirementName)) {
+            Ec.error(`❌ 需求 "${requirementName}" 不存在`);
+            process.exit(1);
+        }
+        
+        // 生成带时间戳的归档目录名 (YYYYMMDDHHMMSS-需求名)
+        const now = new Date();
+        const timestamp = now.getFullYear() + 
+            String(now.getMonth() + 1).padStart(2, '0') + 
+            String(now.getDate()).padStart(2, '0') + 
+            String(now.getHours()).padStart(2, '0') + 
+            String(now.getMinutes()).padStart(2, '0') + 
+            String(now.getSeconds()).padStart(2, '0');
+        
+        const archiveName = `${timestamp}-${requirementName}`;
+        const archiveDir = path.join(archivesDir, archiveName);
+        
+        // 确保归档目录存在
+        if (!fs.existsSync(archivesDir)) {
+            await fsAsync.mkdir(archivesDir, { recursive: true });
+        }
+        
+        // 拷贝需求目录到归档目录
+        const sourceDir = path.join(changesDir, requirementName);
+        Ec.waiting(`正在归档需求 "${requirementName}" 到 "${archiveDir}"`);
+        await _copyDir(sourceDir, archiveDir);
+        
+        // 删除原始需求目录
+        Ec.waiting(`正在删除原始需求目录 "${sourceDir}"`);
+        await _removeDir(sourceDir);
+        
+        Ec.info(`✅ 成功归档需求 "${requirementName}" 为 "${archiveName}"`);
+        process.exit(0);
+    } catch (error) {
+        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        process.exit(1);
+    }
+};

package/src/executor/executeEnv.js

@@ -0,0 +1,158 @@
+const {exec} = require('child_process');
+const util = require('util');
+const Ec = require('../epic');
+const path = require('path');
+const fs = require('fs');
+
+// 将 exec 转换为 Promise 版本
+const execAsync = util.promisify(exec);
+
+/**
+ * 获取项目版本号
+ * @returns {string} 版本号
+ */
+const _getVersion = () => {
+    try {
+        const packagePath = path.resolve(__dirname, '../../package.json');
+        const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+        return packageJson.version || '未知版本';
+    } catch (error) {
+        return '未知版本';
+    }
+};
+
+/**
+ * 检查命令是否存在
+ * @param {string} command 命令名称
+ * @returns {Promise<boolean>} 命令是否存在
+ */
+const _checkCommand = async (command) => {
+    try {
+        await execAsync(`which ${command}`);
+        return true;
+    } catch (error) {
+        try {
+            // 在 Windows 上尝试 where 命令
+            await execAsync(`where ${command}`);
+            return true;
+        } catch (winError) {
+            return false;
+        }
+    }
+};
+
+/**
+ * 获取命令版本信息
+ * @param {string} command 命令名称
+ * @returns {Promise<string>} 命令版本信息
+ */
+const _getCommandVersion = async (command) => {
+    try {
+        const {stdout} = await execAsync(`${command} --version`);
+        return stdout.trim();
+    } catch (error) {
+        try {
+            // 尝试使用 -v 参数
+            const {stdout} = await execAsync(`${command} -v`);
+            return stdout.trim();
+        } catch (vError) {
+            return '未知版本';
+        }
+    }
+};
+
+module.exports = async () => {
+    Ec.waiting('正在检查环境信息...');
+
+    // 需要检查的命令列表
+    const requiredCommands = ['node', 'npm', 'git', 'momo'];
+
+    let allCommandsAvailable = true;
+
+    // 检查每个命令
+    for (const command of requiredCommands) {
+        const isAvailable = await _checkCommand(command);
+
+        if (isAvailable) {
+            // const version = await _getCommandVersion(command);
+            // Ec.waiting(`✅ ${command}: ${version}`);
+        } else {
+            Ec.waiting(`❌ ${command}: 未找到命令`);
+            allCommandsAvailable = false;
+        }
+    }
+
+    Ec.waiting('------------------------------------------------------------');
+
+    // 检查额外的环境信息
+    try {
+        const {stdout: nodeVersion} = await execAsync('node --version');
+        Ec.waiting(`💻 Node.js 版本: ${nodeVersion.trim()}`);
+    } catch (error) {
+        Ec.waiting('⚠️ 无法获取 Node.js 版本信息');
+    }
+
+    try {
+        const {stdout: npmVersion} = await execAsync('npm --version');
+        Ec.waiting(`📦 NPM 版本: ${npmVersion.trim()}`);
+    } catch (error) {
+        Ec.waiting('⚠️ 无法获取 NPM 版本信息');
+    }
+
+    try {
+        const {stdout: gitVersion} = await execAsync('git --version');
+        Ec.waiting(`🌱 Git 版本: ${gitVersion.trim()}`);
+    } catch (error) {
+        Ec.waiting('⚠️ 无法获取 Git 版本信息');
+    }
+
+    // 检查 trae 版本（可选命令）
+    try {
+        const {stdout: traeVersion} = await execAsync('trae --version');
+        const traeItems = (traeVersion.split("\n"));
+        Ec.waiting(`----> 🎯 Trae 版本: ${traeItems[0].trim()}`);
+    } catch (error) {
+        Ec.waiting('⚠️ Trae 未安装或无法获取版本信息（可选工具）');
+    }
+    
+    // 检查 lingma 版本（可选命令）
+    try {
+        const {stdout: lingmaVersion} = await execAsync('lingma --version');
+        const lingmaItems = (lingmaVersion.split("\n"));
+        Ec.waiting(`----> 🧠 Lingma 版本: ${lingmaItems[0].trim()}`);
+    } catch (error) {
+        Ec.waiting('⚠️ Lingma 未安装或无法获取版本信息（可选工具）');
+    }
+    
+    // 检查 cursor 版本（可选命令）
+    try {
+        const {stdout: cursorVersion} = await execAsync('cursor --version');
+        const cursorItems = (cursorVersion.split("\n"));
+        Ec.waiting(`----> 🖱️ Cursor 版本: ${cursorItems[0].trim()}`);
+    } catch (error) {
+        Ec.waiting('⚠️ Cursor 未安装或无法获取版本信息（可选工具）');
+    }
+    
+    // 检查 kiro 版本（可选命令）
+    try {
+        const {stdout: kiroVersion} = await execAsync('kiro --version');
+        const kiroItems = (kiroVersion.split("\n"));
+        Ec.waiting(`----> ⚡ Kiro 版本: ${kiroItems[0].trim()}`);
+    } catch (error) {
+        Ec.waiting('⚠️ Kiro 未安装或无法获取版本信息（可选工具）');
+    }
+
+    // 显示 Momo 版本
+    const momoVersion = _getVersion();
+    Ec.waiting(`🤖 Momo 版本: ${momoVersion}`);
+
+    // 总结（只检查必需命令）
+    if (allCommandsAvailable) {
+        Ec.info('✅ 所有必需的命令都已安装');
+    } else {
+        Ec.waiting('❌ 部分必需的命令未安装，请检查并安装缺失的命令');
+        process.exit(1);
+    }
+
+    process.exit(0);
+};

package/src/executor/executeHelp.js

@@ -0,0 +1,23 @@
+const Ec = require('../epic');
+const os = require('os');
+module.exports = (options) => {
+    const metadata = Ec.parseMetadata();
+    metadata.forEach(runner => {
+        Ec.waiting(`命令：` + `momo ${runner.command} [-options]`.green);
+        Ec.waiting(`说明：${runner.description}`.yellow);
+        const options = runner.options || [];
+        options.forEach(option => {
+            if (option.hasOwnProperty('default')) {
+                const str = option.default + '';
+                Ec.waiting(`\t-${option.alias},--${option.name}`.red + `\t${option.description}, 默认值：\uD83C\uDF37 ` + str.blue);
+            } else {
+                Ec.waiting(`\t-${option.alias},--${option.name}`.red + `\t${option.description}`);
+            }
+        })
+        Ec.waiting();
+    });
+    Ec.info("命令执行完成！");
+
+    // 退出程序
+    process.exit(0);
+}

package/src/executor/executeInit.js

@@ -0,0 +1,321 @@
+const fs = require('fs');
+const path = require('path');
+const Ec = require('../epic');
+const fsAsync = require("fs").promises;
+
+const _ioDirectory = async (baseDir) => {
+    const folders = [
+        ".momo/prompt/",
+        ".momo/template/",
+        ".momo/advanced/",
+        ".momo/scripts/",
+        "specification/",
+        "specification/changes/",
+        "specification/actor/",
+        "specification/.archives/",
+        "specification/.activities/",
+        "source/",
+        "integration/",
+        "integration/openspec/",
+        "integration/spec-kit/",
+        "integration/kiro/",
+        "integration/trea/",
+        "integration/cursor/",
+        "integration/lingma/",
+        "integration/qoder/",
+        "integration/windsurf/",
+        "integration/github/",
+        "integration/claude-code/",
+        "integration/chatgpt/"
+    ];
+
+    // 创建所有目录
+    const results = [];
+    for (const folder of folders) {
+        Ec.waiting("创建目录：" + folder);
+        const directory = path.resolve(baseDir, folder);
+        await fsAsync.mkdir(directory, {recursive: true});
+        results.push(true);
+    }
+    return results;
+}
+
+const _ioFile = async (baseDir) => {
+    /*
+     * 填充空文件目录
+     * .momo/prompt/
+     * .momo/template/                          存放模板目录
+     * .momo/advanced/
+     * .momo/scripts/
+     *
+     * specification/changes/
+     * specification/actor/
+     * specification/.archives/
+     * specification/.activities/
+     *
+     * integration/ 下所有类型的子目录
+     */
+
+    /*
+     * 拷贝文件目录
+     * _template/specification/project.md
+     * _template/specification/project-model.md
+     * _template/specification/requirement.md
+     */
+
+    // 检查是否存在任何已存在的文件
+    let hasExistingFiles = false;
+    const templateDir = path.resolve(__dirname, "../_template/LAIN");
+
+    // 检查模板文件
+    const templateFiles = [
+        {
+            source: "specification/project.md",
+            target: "specification/project.md"
+        },
+        {
+            source: "specification/project-model.md",
+            target: "specification/project-model.md"
+        },
+        {
+            source: "specification/requirement.md",
+            target: "specification/requirement.md"
+        },
+        {
+            source: ".gitignore",
+            target: ".gitignore"
+        },
+        {
+            source: "AGENTS.md",
+            target: "AGENTS.md"
+        }
+    ];
+
+    for (const file of templateFiles) {
+        const sourcePath = path.resolve(templateDir, file.source);
+        const targetPath = path.resolve(baseDir, file.target);
+
+        // 检查源文件是否存在且目标文件已存在
+        if (fs.existsSync(sourcePath) && fs.existsSync(targetPath)) {
+            hasExistingFiles = true;
+            break;
+        }
+    }
+
+    // 检查 actor.md 文件
+    const actorSourcePath = path.resolve(templateDir, ".momo/advanced/actor.md");
+    const actorTargetPath = path.resolve(baseDir, ".momo/advanced/actor.md");
+
+    if (fs.existsSync(actorSourcePath) && fs.existsSync(actorTargetPath)) {
+        hasExistingFiles = true;
+    }
+
+    // 如果有已存在的文件，询问用户是否覆盖
+    let shouldOverwrite = true;
+    if (hasExistingFiles) {
+        const answer = await Ec.ask("检测到已存在文件，是否全部覆盖？(y/N): ");
+        shouldOverwrite = (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        if (!shouldOverwrite) {
+            Ec.waiting("跳过所有已存在文件的覆盖操作");
+        }
+    }
+
+    // 创建空文件的目录列表
+    const emptyFileDirs = [
+        ".momo/prompt/",
+        ".momo/template/",
+        ".momo/scripts/",
+        "specification/changes/",
+        "specification/actor/",
+        "specification/.archives/",
+        "specification/.activities/",
+        "source/",
+        "integration/openspec/",
+        "integration/spec-kit/",
+        "integration/kiro/",
+        "integration/trea/",
+        "integration/cursor/",
+        "integration/lingma/",
+        "integration/qoder/",
+        "integration/windsurf/",
+        "integration/github/",
+        "integration/claude-code/",
+        "integration/chatgpt/"
+    ];
+
+    // 为每个目录创建一个空的 .gitkeep 文件，确保目录被git跟踪
+    for (const dir of emptyFileDirs) {
+        const fullPath = path.resolve(baseDir, dir, ".gitkeep");
+        // 确保目录存在后再创建文件
+        const dirPath = path.dirname(fullPath);
+        if (!fs.existsSync(dirPath)) {
+            await fsAsync.mkdir(dirPath, {recursive: true});
+        }
+
+        if (!fs.existsSync(fullPath)) {
+            Ec.waiting("创建空文件：" + fullPath);
+            await fsAsync.writeFile(fullPath, "");
+        }
+    }
+
+    // 拷贝模板文件
+    for (const file of templateFiles) {
+        const sourcePath = path.resolve(templateDir, file.source);
+        const targetPath = path.resolve(baseDir, file.target);
+
+        // 检查源文件是否存在
+        if (fs.existsSync(sourcePath)) {
+            // 确保目标目录存在
+            const targetDir = path.dirname(targetPath);
+            if (!fs.existsSync(targetDir)) {
+                await fsAsync.mkdir(targetDir, {recursive: true});
+            }
+
+            // 检查目标文件是否已存在
+            if (fs.existsSync(targetPath)) {
+                // 目标文件已存在，根据用户选择决定是否覆盖
+                if (shouldOverwrite) {
+                    Ec.waiting("覆盖模板文件：" + file.target);
+                    await fsAsync.copyFile(sourcePath, targetPath);
+                } else {
+                    Ec.waiting("跳过文件：" + file.target);
+                }
+            } else {
+                Ec.waiting("拷贝模板文件：" + file.target);
+                await fsAsync.copyFile(sourcePath, targetPath);
+            }
+        } else {
+            // 如果模板文件不存在，则创建空文件
+            if (!fs.existsSync(targetPath)) {
+                Ec.waiting("创建空文件：" + targetPath);
+                // 确保目标目录存在
+                const targetDir = path.dirname(targetPath);
+                if (!fs.existsSync(targetDir)) {
+                    await fsAsync.mkdir(targetDir, {recursive: true});
+                }
+                await fsAsync.writeFile(targetPath, "");
+            }
+        }
+    }
+
+    // 拷贝 .momo/advanced/actor.md 文件
+    if (fs.existsSync(actorSourcePath)) {
+        // 确保目标目录存在
+        const actorDir = path.dirname(actorTargetPath);
+        if (!fs.existsSync(actorDir)) {
+            await fsAsync.mkdir(actorDir, {recursive: true});
+        }
+
+        // 检查目标文件是否已存在
+        if (fs.existsSync(actorTargetPath)) {
+            // 目标文件已存在，根据用户选择决定是否覆盖
+            if (shouldOverwrite) {
+                Ec.waiting("覆盖模板文件：" + ".momo/advanced/actor.md");
+                await fsAsync.copyFile(actorSourcePath, actorTargetPath);
+            } else {
+                Ec.waiting("跳过文件：.momo/advanced/actor.md");
+            }
+        } else {
+            Ec.waiting("拷贝模板文件：" + ".momo/advanced/actor.md");
+            await fsAsync.copyFile(actorSourcePath, actorTargetPath);
+        }
+    } else {
+        // 如果模板文件不存在，则创建空文件
+        if (!fs.existsSync(actorTargetPath)) {
+            Ec.waiting("创建文件：" + actorTargetPath);
+            // 确保目标目录存在
+            const actorDir = path.dirname(actorTargetPath);
+            if (!fs.existsSync(actorDir)) {
+                await fsAsync.mkdir(actorDir, {recursive: true});
+            }
+
+            await fsAsync.writeFile(actorTargetPath, "");
+        }
+    }
+
+    // 确保 .momo/advanced/ 目录存在
+    const momoAdvancedDir = path.resolve(baseDir, ".momo/advanced/");
+    if (!fs.existsSync(momoAdvancedDir)) {
+        await fsAsync.mkdir(momoAdvancedDir, {recursive: true});
+    }
+}
+
+/**
+ * 目录结构说明
+ * .momo/prompt/                                存放备注目录
+ * .momo/template/                              存放模板目录
+ * .momo/advanced/                              高级配置说明
+ *               /actor.md                       - 角色定制说明
+ * .momo/scripts/                               特殊脚本目录
+ *
+ * specification/                               工作目录
+ *              /project.md                      - 项目基本说明文件
+ *              /project-model.md                - 模型说明文件（通常是建模所需的核心概念模型）
+ *
+ *              --------- 需求分析 / 任务分配设计 / 角色定制 ------------
+ *              /requirement.md                                 - 基础需求说明（第一份）
+ *              /changes/                                       变更详情
+ *                   /change-XXX/
+ *                              /implementation.md              实现方案步骤说明
+ *                              /proposal.md                    ( OpenSpec ) 变更提案说明文件
+ *                              /tasks.md                       ( OpenSpec ) 变更任务列表说明 -> 链接到 tasks/ 目录下的具体任务清单中
+ *                              /tasks                          计划详细内容，如果拆分成 Task 则对应到 Tasks/plan-XXX/ 目录中
+ *                                    /M01-T001-01.md           具体任务文件，M代表模块，T代表任务，001代表任务编号，01代表子任务序号
+ *                                    /M01-T001-02.md           ......
+ *                              /design.md                      ( OpenSpec ) 变更设计说明文件
+ *                              /change.md                      ( OpenSpec -> specs/profile/spec.md ) 变更说明文件
+ *              /actor/                                         角色目录 / 定义了 Agent 所具有的角色信息，可自定义角色
+ *                    /{name}/stack.md                          角色技能（技术栈）说明文件
+ *                    /{name}/limit.md                          角色限制说明文件
+ *              /.archives/                                     归档记录
+ *              /.activities/
+ *                    /actor@plan-XXX/                          角色在某个计划下的历史执行记录（带时间戳）
+ * source/                                      源代码目录
+ *       /develop-01
+ *       /develop-02
+ *       /develop-03
+ * integration/                                 集成目录（特殊集成配置）
+ *   openspec/                                  OpenSpec 目录
+ *           /config.json                       配置文件
+ *   spec-kit/                                  SpecKit 目录
+ *   kiro/                                      Kiro 目录
+ *   trea/                                      Trea 目录
+ *   cursor/                                    Cursor 目录
+ *   lingma/                                    Lingma 目录
+ *   qoder/                                     Qoder 目录
+ *   windsurf/                                  WindSurf 目录
+ *   github/                                    Github Copilot 目录
+ *   claude-code/                               Claude Code 目录
+ *   chatgpt/                                   ChatGPT 目录
+ * @param options
+ */
+module.exports = (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+    /*
+     * 基本信息
+     */
+    const directory = parsed.directory || '.';
+    // 创建基础目录结构
+    const basePath = path.resolve(process.cwd(), directory);
+
+    Ec.waiting(`准备在目录 "${basePath}" 中初始化 Spec 工程...`);
+
+    // 创建目录结构
+    _ioDirectory(basePath)
+        .then(() => _ioFile(basePath))
+        .then(() => {
+            Ec.info('✅ SPEC / 项目初始化完成！');
+            // 关闭 readline 接口
+            Ec.askClose();
+            // 退出程序
+            process.exit(0);
+        })
+        .catch((error) => {
+            Ec.error('项目初始化失败: ' + error.message);
+            // 关闭 readline 接口
+            Ec.askClose();
+            // 退出程序
+            process.exit(1);
+        });
+}