momo-ai 1.0.0 → 1.0.1

package/src/epic/momo.fn.to.js

@@ -0,0 +1,74 @@
+const U = require("underscore");
+
+// Import
+const __IT = require("./momo.fn.it");
+
+const __CX = require("./momo.fn.cx");
+const __FX = require("./momo.fn.fx");
+
+const __LOG = require("./momo.fn.log");
+// Import Private
+const __U = require("./momo.fn.find");
+
+const __csvJObject = (object = {}, keysData) => {
+    const values = [];
+    const keys = keysData ? keysData : Object.keys(object);
+    keys.forEach(key => values.push(undefined !== object[key] ? object[key] : ""));
+    return values;
+};
+const toJArray = (content = "") => {
+    __CX.cxJString(content);
+    return JSON.parse(content);
+};
+
+const toJObject = (content = "") => {
+    __CX.cxJString(content);
+    return JSON.parse(content);
+};
+
+const toCsv = (array = [], mapping = {}, seperator) => {
+    let lines = [];
+    if (U.isArray(array) && 0 < array.length) {
+        const keys = __U.findMaxFields(array);
+        // 转换字段信息
+        const formatted = {};
+        keys.forEach(key => formatted[key] = key);
+        __IT.itObject(mapping, (from, to) => {
+            if (formatted.hasOwnProperty(from)) {
+                __LOG.info(`字段执行转换：${from.red} -> ${to.blue}`);
+                formatted[to] = to;
+                delete formatted[from];
+            }
+        });
+        const header = Object.keys(formatted);
+        lines.push(header.join(seperator));
+        array.forEach(each => {
+            __IT.itObject(mapping, (from, to) => {
+                if (each.hasOwnProperty(from)) {
+                    each[to] = each[from];
+                    delete each[from];
+                }
+            });
+            const line = __csvJObject(each, Object.keys(formatted));
+            lines.push(line.join(seperator));
+        });
+        return lines;
+    } else {
+        __FX.fxError(10001, `value = ${JSON.stringify(array)}, type = ${typeof array}`, "Array")
+    }
+    return lines;
+};
+const toTable = (record = {}) => {
+    const content = [];
+    content.push(`参数名\t\t|\t参数值\t\t|`.blue);
+    content.push(`-----------------------------------------`.yellow);
+    Object.keys(record).forEach(field => content.push(`${field}\t\t|\t${record[field]}\t\t|`));
+    content.push(`-----------------------------------------`.yellow);
+    return content.join("\n");
+}
+module.exports = {
+    toCsv,
+    toJArray,
+    toJObject,
+    toTable,
+}

package/src/epic/momo.v.constant.js

@@ -0,0 +1,5 @@
+const path = require('path');
+
+module.exports = {
+    FILE_DELIMITER: path.sep,
+}

package/src/epic/momo.v.errorcode.js

@@ -0,0 +1,108 @@
+/**
+ * ## `Ec.E`
+ *
+ * ### 1. 基本介绍
+ *
+ * 该类为错误信息定义专用类，方法名采用`fn<Code>`的方式执行最终输出的错误信息内容。通常使用下边代码：
+ *
+ * ```js
+ * // 第一种调用方法：第一参直接是错误代码
+ * Ec.fxError(10001, arg1, arg2);
+ *
+ * // 第二种调用方法：第一参是Boolean值，true就输出，第二参是错误代码
+ * const checked = true;
+ * Ec.fxError(checked, 10001, arg1, arg2);
+ *
+ * // 第三种调用方法：第一参是Function，执行后结果为true就输出，第二参是错误代码
+ * const fnChecked = () => true;
+ * Ec.fxError(fnChecked, 10001, arg1, arg2);
+ * ```
+ *
+ * ### 2. 错误代码表
+ *
+ * |代码|参数表|含义|
+ * |---|---|:---|
+ * |10001|`arg,type`|输入参数类型不匹配。|
+ * |10002|`arg,type,expected`|「带期望」输入参数和期望参数不匹配。|
+ * |10003|`fileType`|文件类型无法被解析。|
+ * |10004|`command`|无法识别命令名，不在可解析的命令中。|
+ * |10005|`command,expected`|「带期望」输入的命令不在期望的命令列表中。|
+ * |10006|`arg`|命令执行中丢失了必须的参数。|
+ * |10007|`path`|输入的目录不存在，或者输入路径并不是一个目录。|
+ * |10008|`path`|目录不存在，或输入路径是一个文件。|
+ * |10009|`path`|路径直接不存在，不论目录还是文件都不存在。|
+ * |10010|`projects`|系统检测到两个或两个以上的项目目录，系统无法定位操作项目环境。|
+ * |10011|`config`|「后端」配置数据中丢失了`api`属性值。|
+ * |10012|`member,clazz`|「后端」在查找的`clazz`类名中无法找到（成员变量/成员函数）`member`。|
+ * |10013|`lineType`|工具无法分析行类型，输入的文件内容不符合Zero Ai的基本规范，无法解析源代码。|
+ * |10014|`pkg`|「后端」系统找到了超过两个以上的`package`语句，这个在定义过程中是非法的，不可连续执行。|
+ * |10015|`method,clazz`|「后端」在查找的`clazz`类名中找到了重复的（成员函数/成员变量）`method`，所以非法。|
+ * |10016|`command`|「前端」Zero UI规范错误，不可执行当前命令。|
+ * |10017|`root`|「前端」Zero项目的目录并非一个合法的项目目录，请定位到合法的项目目录中。|
+ * |10018|`resource`|「前端」资源文件绑定过程中出现了资源错误，请检查环境或执行命令。|
+ * |10019|`root`|「前端」当前命令只能在项目根目录中执行（带有package.json文件），其他目录不可执行该方法。|
+ * |10020|`menuData`|「前端」当前菜单数据必须是一个合法的Array类型，当前类型不对。|
+ * |10021|`field,value`|条件`field=value`引起了重复数据记录，导致不匹配UK规范，检查重复数据专用错误。|
+ * |10022|`root`|「前端/后端」无法定位项目的根目录，不可执行项目专用类命令。|
+ * |10023|`folder`|「前端」初始化项目时检测到输入的文件路径是一个非空目录，不可执行Zero AI的初始化。|
+ * |10024|`path`|当前操作和输入的路径冲突，不可在路径中执行操作指令。|
+ * |10025|`configKey`|「前端」配置项主键丢失了核心配置，在生成前端Web组件时出现了规范冲突。|
+ * |10026|`path`|「前端」输入路径非法，不在支持的Zero Ui专用路径规范中。|
+ * |10027|`modulePath`|「前端」输入路径必须是`<module>/<page>`格式，当前路径并非该格式，和规范冲突。|
+ * |10028|`arg`|「前端」模块参数不在枚举值中，必须是四者之一：`FORM, FILTER, HALF, EDIT`。|
+ * |10029|`zt`|「带期望」环境变量缺失或者格式不对，必须是`<module>/<page>`格式。|
+ * |10030|`arg, key`|「开发专用」方法要求资源文件中必须包含`key`属性，当前`key`属性值不对。|
+ * |10031|`id`|「开发专用」当前HTML按钮元素要求`btn`前缀，输入前缀不合法。|
+ * |10032|`platform`|操作系统不支持当前命令，或者该操作系统平台中还未实现该命令的执行逻辑。|
+ * |10033|`path`|当前路径不符合Zero专用规范（基础Java/Maven规范）。|
+ * |10034|`path`|当前路径不符合Ox平台专用规范。|
+ *
+ * @class E
+ */
+module.exports = {
+    // 基础
+    fn10001: (arg, type) => `[AI-10001] Argument must be '${type}', but now it's '${arg}'`,
+    fn10002: (arg, type, expected) => `[AI-10002] Argument must be in (${expected}), but now it's '${arg}' of '${type}'`,
+
+    // 命令
+    fn10003: (fileType) => `[AI-10003] The fileType='${fileType}' is unknown and could not found parser`,
+    fn10004: (command) => `[AI-10004] The executor of command '${command}' could not be found（执行器丢失）`,
+    fn10005: (command = "未输入", expected) => `[AI-10005] The command '${command}' could not be found, expected '${expected}'`,
+    fn10006: (arg) => `[AI-10006] The command missed required arguments: '${arg}'`,
+
+    // 路径
+    fn10007: (path) => `[AI-10007] The file '${path}' does not exist or it's a directory.`,
+    fn10008: (path) => `[AI-10008] The directory '${path}' does not exist or it's a file.`,
+    fn10009: (path) => `[AI-10009] The path '${path}' does not exist.`,
+
+    // 后端
+    fn10010: (projects = []) => `[AI-10010] The tool detect more than one project folders, found '${projects.length}', please switch.`,
+    fn10011: (config) => `[AI-10011] 'api' attribute has been missed in current config ${JSON.stringify(config)}`,
+    fn10012: (member, clazz) => `[AI-10012] Duplicated member '${member}' found in class '${clazz}', please check.`,
+    fn10013: (lineType) => `[AI-10013] Zero system could not analyze the code line type, type = ${lineType} is Unknown`,
+    fn10014: (pkg) => `[AI-10014] More than one 'package' sentence found.${JSON.stringify(pkg)}`,
+    fn10015: (method, clazz) => `[AI-10015] Duplicated method '${method}' found in class '${clazz}', please check.`,
+
+    // 前端
+    fn10016: (command) => `[AI-10016] Zero UI specification wrong, you could not execute in '${command}'`,
+    fn10017: (root) => `[AI-10017] Current folder '${root}' is not project folder, please switch to project root directory`,
+    fn10018: (resource) => `[AI-10018] Zero Resource config file missing '${resource}', please check.`,
+    fn10019: (root) => `[AI-10019] This command could run in project root folder only, current folder = ${root}`,
+    fn10020: (menuData) => `[AI-10020] The menu data file must be json format with 'data' (Array) node, current = ${menuData}`,
+    fn10021: (field, value) => `[AI-10021] The condition '${field} = ${value}' hit duplicated record in your file.`,
+    fn10022: (root) => `[AI-10022] Could not find root folder of current project. ${root}`,
+    fn10023: (folder) => `[AI-10023] Initialized folder must be empty, current ${folder} is invalid`,
+    fn10024: (path) => `[AI-10024] This operation is not allowed for current path ${path}`,
+    fn10025: (configKey) => `[AI-10025] Web control initialized require "actual.data" must be string, current:${configKey}`,
+    fn10026: (path) => `[AI-10026] The path is invalid, ${path}, system support one of ".", "src/components/xxx", "xxx".`,
+    fn10027: (modulePath) => `[AI-10027] The path must be formatted with "<module>/<page>", could not be others, current = ${modulePath}`,
+    fn10028: (arg) => `[AI-10028] The "module" parameter must be one of "FORM", "FILTER", "HALF", "EDIT" values. current = ${arg}`,
+    fn10029: (zt, name) => `[AI-10029] [DEV] You'll use development command, please set "${name}" environment first, current = ${zt}. React format = "<module>/<page>", Java for other.`,
+    fn10030: (arg, key) => `[AI-10030] [DEV] This method require "${key}" in your resource file, but current "${key}" = ${arg}`,
+    fn10031: (id) => `[AI-10031] [DEV] Button key must start with "btn", current ${id}`,
+    fn10032: (platform) => `[AI-10032] This api is not implemented in current platform os.platform() -> '${platform}'`,
+    fn10033: (path) => `[AI-10033] (Zero) Current path '${path}' is not correct Zero work folder under specification`,
+    fn10034: (path) => `[AI-10034] (Ox) Current path '${path}' is not correct Ox work folder`,
+    fn10035: (path) => `[AI-10035] (Mod) The "initialize.json" configuration file has been missed in '${path}'`,
+    fn10036: (mode) => `[AI-10036] (Mod) The mode must be in "REPLACE, APPEND", could not been parsed: ${mode}`,
+};

package/src/executor/executeActor.js

@@ -0,0 +1,113 @@
+const Ec = require('../epic');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 交互式选择LLM
+ */
+const _selectLLM = async (actorName) => {
+    Ec.waiting('🤖 请选择要使用的LLM:');
+
+    const llmOptions = [
+        {name: 'OpenSpec', value: 'openspec'},
+        {name: 'SpecKit', value: 'spec-kit'},
+        {name: 'Kiro', value: 'kiro'},
+        {name: 'Trea', value: 'trea'},
+        {name: 'Cursor', value: 'cursor'},
+        {name: 'Lingma', value: 'lingma'},
+        {name: 'Qoder', value: 'qoder'},
+        {name: 'WindSurf', value: 'windsurf'},
+        {name: 'GitHub Copilot', value: 'github'},
+        {name: 'Claude Code', value: 'claude-code'},
+        {name: 'ChatGPT', value: 'chatgpt'}
+    ];
+
+    // 显示选项
+    llmOptions.forEach((option, index) => {
+        Ec.waiting(`${index + 1}. ${option.name}`);
+    });
+
+    // 获取用户选择
+    const answer = await Ec.ask('请输入选项编号: ');
+    const selectedIndex = parseInt(answer) - 1;
+
+    // 验证选择
+    if (isNaN(selectedIndex) || selectedIndex < 0 || selectedIndex >= llmOptions.length) {
+        Ec.error('❌ 无效的选择');
+        return _selectLLM(actorName); // 重新选择
+    }
+
+    const selectedLLM = llmOptions[selectedIndex];
+
+    // 获取 token 配置信息
+    const token = await Ec.ask(`请输入 ${selectedLLM.name} 的 Token (可选): `);
+
+    return {
+        llm: selectedLLM.value,
+        name: actorName,
+        token: token || ''
+    };
+};
+
+module.exports = (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+
+    const actorName = parsed.name;
+    Ec.waiting(`🔍 准备创建角色: ${actorName}`);
+
+    // 创建角色目录
+    const actorDir = path.resolve(process.cwd(), 'specification', 'actor', actorName);
+    if (!fs.existsSync(actorDir)) {
+        Ec.waiting(`📁 创建角色目录: ${actorDir}`);
+        fs.mkdirSync(actorDir, {recursive: true});
+    } else {
+        Ec.waiting(`✅ 角色目录已存在: ${actorDir}`);
+    }
+
+    // 从模板复制内容到stack.md和limit.md
+    const templatePath = path.resolve(__dirname, '../_template/LAIN/.momo/advanced/actor.md');
+    if (fs.existsSync(templatePath)) {
+        const templateContent = fs.readFileSync(templatePath, 'utf8');
+
+        // 提取技能说明部分作为stack.md的内容
+        const stackMatch = templateContent.match(/## 技能说明\s*([\s\S]*?)\s*## 角色限制/);
+        if (stackMatch && stackMatch[1]) {
+            const stackContent = `# 技术栈信息\n\n${stackMatch[1].trim()}\n`;
+            const stackPath = path.resolve(actorDir, 'stack.md');
+            fs.writeFileSync(stackPath, stackContent);
+            Ec.waiting(`📄 创建技术栈文件: ${stackPath}`);
+        }
+
+        // 提取角色限制部分作为limit.md的内容
+        const limitMatch = templateContent.match(/## 角色限制\s*([\s\S]*)/);
+        if (limitMatch && limitMatch[1]) {
+            const limitContent = `# 角色限制\n\n${limitMatch[1].trim()}\n`;
+            const limitPath = path.resolve(actorDir, 'limit.md');
+            fs.writeFileSync(limitPath, limitContent);
+            Ec.waiting(`📄 创建限制文件: ${limitPath}`);
+        }
+    }
+
+    // 交互式选择LLM
+    _selectLLM(actorName)
+        .then((llmConfig) => {
+            // 创建config.json文件
+            const configPath = path.resolve(actorDir, 'config.json');
+            fs.writeFileSync(configPath, JSON.stringify(llmConfig, null, 4));
+            Ec.waiting(`⚙️  创建配置文件: ${configPath}`);
+
+            Ec.info(`✅ 角色 "${actorName}" 创建完成`);
+            // 关闭 readline 接口
+            Ec.askClose();
+            // 退出程序
+            process.exit(0);
+        })
+        .catch((error) => {
+            Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+            // 关闭 readline 接口
+            Ec.askClose();
+            // 退出程序
+            process.exit(1);
+        });
+};

package/src/executor/executeActors.js

@@ -0,0 +1,58 @@
+const Ec = require('../epic');
+const fs = require('fs');
+const path = require('path');
+
+module.exports = (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+
+    try {
+        // 获取 actor 目录路径
+        const actorsDir = path.resolve(process.cwd(), 'specification', 'actor');
+        
+        // 检查目录是否存在
+        if (!fs.existsSync(actorsDir)) {
+            Ec.error("❌ 未找到 actor 目录，请先初始化项目或创建角色");
+            Ec.askClose();
+            process.exit(1);
+        }
+
+        // 读取所有 actor 目录
+        const actors = fs.readdirSync(actorsDir).filter(file => 
+            fs.statSync(path.join(actorsDir, file)).isDirectory()
+        );
+
+        if (actors.length === 0) {
+            Ec.waiting("🔍 未找到任何角色");
+            Ec.askClose();
+            process.exit(0);
+        }
+
+        // 遍历所有 actor 并读取配置
+        actors.forEach((actorName, index) => {
+            const configPath = path.resolve(actorsDir, actorName, 'config.json');
+            let llm = '-';
+            let token = '-';
+            
+            if (fs.existsSync(configPath)) {
+                try {
+                    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+                    llm = config.llm || '-';
+                    token = config.token || '-';
+                } catch (e) {
+                    // 解析配置文件出错，保持默认值
+                }
+            }
+            
+            // 输出格式：序号. 名称 （ LLM = ??, Token = ?? )
+            Ec.waiting(`${index + 1}. ${actorName} （ LLM = ${llm}, Token = ${token} )`);
+        });
+
+        Ec.askClose();
+        process.exit(0);
+    } catch (error) {
+        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        Ec.askClose();
+        process.exit(1);
+    }
+};

package/src/executor/executeAdd.js

@@ -0,0 +1,248 @@
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+const { spawn } = require('child_process');
+const Ec = require('../epic');
+const fsAsync = require('fs').promises;
+
+/**
+ * 读取模板文件并提取 <!-- BEGIN --> 到 <!-- END --> 之间的内容
+ * @param {string} templatePath 模板文件路径
+ * @returns {Promise<string>} 提取的模板内容
+ */
+const _readTemplate = 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) {
+        Ec.waiting(`读取模板文件失败: ${error.message}`);
+        throw error;
+    }
+};
+
+/**
+ * 渲染 EJS 模板
+ * @param {string} template 模板内容
+ * @param {Object} data 数据对象
+ * @returns {string} 渲染后的内容
+ */
+const _renderTemplate = (template, data) => {
+    let result = template;
+    for (const key in data) {
+        if (data.hasOwnProperty(key)) {
+            const regex = new RegExp(`<%=\\s*${key}\\s*%>`, 'g');
+            result = result.replace(regex, data[key]);
+        }
+    }
+    return result;
+};
+
+/**
+ * 检查需求目录是否已存在
+ * @param {string} changesDir changes目录路径
+ * @param {string} requirementName 需求名称
+ * @returns {boolean} 是否存在
+ */
+const _isRequirementExists = (changesDir, requirementName) => {
+    const requirementDir = path.join(changesDir, requirementName);
+    return fs.existsSync(requirementDir);
+};
+
+/**
+ * 从 Markdown 文件中提取第一个标题作为需求名称
+ * @param {string} filePath 文件路径
+ * @returns {Promise<string>} 第一个标题内容
+ */
+const _extractTitleFromMarkdown = async (filePath) => {
+    try {
+        const content = await fsAsync.readFile(filePath, 'utf8');
+        const lines = content.split('\n');
+        
+        for (const line of lines) {
+            // 匹配 # 开头的标题行
+            const titleMatch = line.match(/^#\s+(.+)$/);
+            if (titleMatch) {
+                return titleMatch[1].trim();
+            }
+        }
+        
+        // 如果没有找到标题，使用文件名（不含扩展名）作为需求名称
+        const fileName = path.basename(filePath);
+        return fileName.replace(/\.[^/.]+$/, ""); // 移除扩展名
+    } catch (error) {
+        Ec.waiting(`读取文件失败: ${error.message}`);
+        throw error;
+    }
+};
+
+/**
+ * 创建需求目录并拷贝模板文件
+ * @param {string} templateDir 模板目录
+ * @param {string} targetDir 目标目录
+ * @param {string} sourceFilePath 源文件路径（可选）
+ */
+const _copyTemplateFiles = async (templateDir, targetDir, sourceFilePath = null) => {
+    try {
+        // 确保目标目录存在
+        if (!fs.existsSync(targetDir)) {
+            await fsAsync.mkdir(targetDir, { recursive: true });
+        }
+        
+        let proposalSource = path.join(templateDir, 'proposal.md');
+        const proposalTarget = path.join(targetDir, 'proposal.md');
+        
+        // 如果提供了源文件路径，则使用源文件内容覆盖 proposal.md
+        if (sourceFilePath && fs.existsSync(sourceFilePath)) {
+            proposalSource = sourceFilePath;
+            Ec.waiting(`从文件 "${sourceFilePath}" 拷贝内容到 proposal.md`);
+            await fsAsync.copyFile(sourceFilePath, proposalTarget);
+        } else if (fs.existsSync(proposalSource)) {
+            Ec.waiting(`拷贝文件: ${proposalTarget}`);
+            await fsAsync.copyFile(proposalSource, proposalTarget);
+        }
+        
+        // 拷贝 tasks.md
+        const tasksSource = path.join(templateDir, 'tasks.md');
+        const tasksTarget = path.join(targetDir, 'tasks.md');
+        if (fs.existsSync(tasksSource)) {
+            Ec.waiting(`拷贝文件: ${tasksTarget}`);
+            await fsAsync.copyFile(tasksSource, tasksTarget);
+        }
+        
+        // 创建 tasks 目录
+        const tasksDir = path.join(targetDir, 'tasks');
+        if (!fs.existsSync(tasksDir)) {
+            Ec.waiting(`创建目录: ${tasksDir}`);
+            await fsAsync.mkdir(tasksDir, { recursive: true });
+        }
+        
+        // 拷贝 task-detail.md 到 tasks 目录
+        const taskDetailSource = path.join(templateDir, 'tasks', 'task-detail.md');
+        const taskDetailTarget = path.join(tasksDir, 'M01-T001-01.md'); // 示例任务文件名
+        if (fs.existsSync(taskDetailSource)) {
+            Ec.waiting(`拷贝文件: ${taskDetailTarget}`);
+            await fsAsync.copyFile(taskDetailSource, taskDetailTarget);
+        }
+    } catch (error) {
+        Ec.waiting(`拷贝模板文件失败: ${error.message}`);
+        throw error;
+    }
+};
+
+/**
+ * 将内容复制到剪贴板（去除换行符）
+ * @param {string} content 要复制的内容
+ */
+const _copyToClipboard = async (content) => {
+    try {
+        // 去除换行符，将内容合并为一行
+        const contentWithoutNewlines = content.replace(/\r?\n|\r/g, ' ');
+        const proc = spawn('pbcopy', { stdio: 'pipe' });
+        proc.stdin.write(contentWithoutNewlines);
+        proc.stdin.end();
+        Ec.waiting('✅ 提示词已复制到剪贴板');
+    } catch (error) {
+        Ec.waiting(`复制到剪贴板失败: ${error.message}`);
+        // 在非 macOS 系统上可能没有 pbcopy，提供备选方案
+        Ec.waiting('提示词内容:');
+        console.log(content);
+    }
+};
+
+module.exports = async (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+    
+    // 获取需求名称
+    let requirementName = parsed.name || parsed.n;
+    
+    // 验证参数
+    if (!requirementName) {
+        Ec.error("❌ 请提供需求名称或需求文件路径 (-n, --name)");
+        process.exit(1);
+    }
+    
+    // 检查是否包含扩展名
+    const hasExtension = path.extname(requirementName) !== '';
+    
+    // 如果包含扩展名，视为文件路径处理
+    let sourceFilePath = null;
+    if (hasExtension) {
+        // 检查文件是否存在
+        if (!fs.existsSync(requirementName)) {
+            // 检查是否在当前目录下存在
+            const fullPath = path.resolve(process.cwd(), requirementName);
+            if (!fs.existsSync(fullPath)) {
+                Ec.error(`❌ 文件 "${requirementName}" 不存在`);
+                process.exit(1);
+            }
+            sourceFilePath = fullPath;
+        } else {
+            sourceFilePath = requirementName;
+        }
+        
+        // 从文件中提取标题作为需求名称
+        requirementName = await _extractTitleFromMarkdown(sourceFilePath);
+    }
+    
+    // 检查需求名称是否包含点号（除了允许的独立需求）
+    if (!hasExtension && requirementName.includes('.')) {
+        Ec.error("❌ 独立需求名称不能包含点号(.)，以防止与文件扩展名混淆");
+        process.exit(1);
+    }
+    
+    Ec.waiting(`准备添加新需求: ${requirementName}`);
+    
+    try {
+        // 获取项目路径
+        const projectDir = process.cwd();
+        const changesDir = path.join(projectDir, 'specification', 'changes');
+        const templateDir = path.join(__dirname, '../_template/LAIN/changes');
+        const promptTemplatePath = path.join(__dirname, '../_template/PROMPT/add.md.ejs');
+        
+        // 检查需求是否已存在
+        if (_isRequirementExists(changesDir, requirementName)) {
+            Ec.error(`❌ 需求 "${requirementName}" 已存在`);
+            process.exit(1);
+        }
+        
+        // 创建需求目录
+        const requirementDir = path.join(changesDir, requirementName);
+        Ec.waiting(`创建需求目录: ${requirementDir}`);
+        await fsAsync.mkdir(requirementDir, { recursive: true });
+        
+        // 拷贝模板文件
+        await _copyTemplateFiles(templateDir, requirementDir, sourceFilePath);
+        
+        // 读取并处理提示词模板
+        const templateContent = await _readTemplate(promptTemplatePath);
+        const renderedContent = _renderTemplate(templateContent, { NAME: requirementName });
+        
+        // 将提示词复制到剪贴板
+        await _copyToClipboard(renderedContent);
+        
+        Ec.info(`✅ 成功添加新需求 "${requirementName}"`);
+        process.exit(0);
+    } catch (error) {
+        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        process.exit(1);
+    }
+};