momo-ai 1.0.0 → 1.0.1

package/src/executor/executeTasks.js

@@ -0,0 +1,260 @@
+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} content 要复制的内容
+ */
+const _copyToClipboard = async (content) => {
+    try {
+        Ec.waiting("📋 正在将内容复制到剪切板...");
+        const proc = spawn('pbcopy', { stdio: 'pipe' });
+        proc.stdin.write(content);
+        proc.stdin.end();
+        
+        // 等待复制操作完成
+        await new Promise((resolve, reject) => {
+            proc.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                } else {
+                    reject(new Error(`pbcopy 进程退出码: ${code}`));
+                }
+            });
+            proc.on('error', reject);
+        });
+        
+        Ec.waiting('📄 任务检查提示词已拷贝到剪切板');
+    } catch (error) {
+        Ec.waiting(`⚠️  无法拷贝到剪切板: ${error.message}`);
+        // 备选方案：显示内容
+        Ec.waiting('提示词内容:');
+        console.log(content);
+    }
+};
+
+/**
+ * 处理剪切板任务
+ * @param {string} taskName 任务名称
+ * @param {Array} taskInstances 任务实例列表
+ */
+const _handleClipboardTask = async (taskName, taskInstances) => {
+    // 读取模板文件并填充参数，然后拷贝到剪切板
+    const templatePath = path.resolve(__dirname, '../_template/PROMPT/tasks.md.ejs');
+    Ec.waiting(`📄 读取模板文件: ${templatePath}`);
+    
+    if (fs.existsSync(templatePath)) {
+        try {
+            // 读取并处理提示词模板
+            const templateContent = await _readTemplate(templatePath);
+            Ec.waiting("🔧 渲染模板参数");
+            
+            const renderedContent = _renderTemplate(templateContent, { 
+                REQ: taskInstances[0].requirement,
+                TASK: taskName
+            });
+            
+            Ec.waiting("📋 准备复制到剪切板");
+            Ec.waiting(`📋 剪切板内容预览: ${renderedContent.substring(0, 50)}${renderedContent.length > 50 ? '...' : ''}`);
+            
+            // 将提示词复制到剪贴板
+            await _copyToClipboard(renderedContent);
+        } catch (error) {
+            Ec.waiting(`⚠️  处理模板时出错: ${error.message}`);
+        }
+    } else {
+        Ec.waiting(`⚠️  未找到模板文件: ${templatePath}`);
+    }
+};
+
+module.exports = async (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+    const taskName = parsed.task;
+    
+    try {
+        // 获取 changes 目录路径
+        const changesDir = path.resolve(process.cwd(), 'specification', 'changes');
+        
+        // 检查目录是否存在
+        if (!fs.existsSync(changesDir)) {
+            Ec.error("❌ 未找到 changes 目录，请先初始化项目");
+            Ec.askClose();
+            process.exit(1);
+        }
+        
+        // 获取所有需求目录
+        const requirements = fs.readdirSync(changesDir).filter(file => 
+            fs.statSync(path.join(changesDir, file)).isDirectory()
+        );
+        
+        if (requirements.length === 0) {
+            Ec.waiting("🔍 未找到任何需求");
+            Ec.askClose();
+            process.exit(0);
+        }
+        
+        Ec.waiting(`📁 找到 ${requirements.length} 个需求目录`);
+        
+        // 如果指定了任务名称，只检查该任务的重复信息
+        if (taskName) {
+            Ec.waiting(`🔍 检查任务 ${taskName} 的重复信息...`);
+            
+            const taskInstances = [];
+            
+            // 查找指定任务
+            requirements.forEach(requirement => {
+                const tasksDir = path.resolve(changesDir, requirement, 'tasks');
+                
+                // 检查 tasks 目录是否存在
+                if (fs.existsSync(tasksDir) && fs.statSync(tasksDir).isDirectory()) {
+                    const taskFile = `${taskName}.md`;
+                    const taskPath = path.resolve(tasksDir, taskFile);
+                    
+                    // 检查任务文件是否存在
+                    if (fs.existsSync(taskPath)) {
+                        const relativePath = path.relative(process.cwd(), taskPath);
+                        taskInstances.push({
+                            name: taskName,
+                            path: relativePath,
+                            requirement: requirement
+                        });
+                    }
+                }
+            });
+            
+            if (taskInstances.length === 0) {
+                Ec.waiting(`✅ 未找到任务 ${taskName}`);
+                // 即使未找到任务也执行剪切板任务
+                await _handleClipboardTask(taskName, [{ requirement: 'unknown' }]);
+                Ec.info(`✅ 任务 ${taskName} 的检查完成`);
+                Ec.askClose();
+                process.exit(0);
+            } else if (taskInstances.length === 1) {
+                Ec.waiting(`✅ 任务 ${taskName} 无重复`);
+                Ec.waiting(`   - ${taskInstances[0].path}`);
+                // 即使无重复也执行剪切板任务
+                await _handleClipboardTask(taskName, taskInstances);
+                Ec.info(`✅ 任务 ${taskName} 的检查完成`);
+                Ec.askClose();
+                process.exit(0);
+            } else {
+                Ec.waiting(`⚠️  发现 ${taskInstances.length} 个重复任务 ${taskName}:`);
+                taskInstances.forEach((task, index) => {
+                    Ec.waiting(`   ${index + 1}. ${task.path}`);
+                });
+                
+                // 执行剪切板任务
+                await _handleClipboardTask(taskName, taskInstances);
+                Ec.info(`✅ 任务 ${taskName} 的重复检查完成`);
+                Ec.askClose();
+                process.exit(0);
+            }
+        }
+        
+        // 未指定任务名称，列出所有任务
+        const tasks = [];
+        
+        requirements.forEach(requirement => {
+            const tasksDir = path.resolve(changesDir, requirement, 'tasks');
+            
+            // 检查 tasks 目录是否存在
+            if (fs.existsSync(tasksDir) && fs.statSync(tasksDir).isDirectory()) {
+                // 获取所有 .md 文件
+                const taskFiles = fs.readdirSync(tasksDir).filter(file => 
+                    file.endsWith('.md')
+                );
+                
+                taskFiles.forEach(taskFile => {
+                    const name = path.basename(taskFile, '.md');
+                    const taskPath = path.relative(process.cwd(), path.resolve(tasksDir, taskFile));
+                    
+                    tasks.push({
+                        name: name,
+                        path: taskPath,
+                        requirement: requirement
+                    });
+                });
+            }
+        });
+        
+        if (tasks.length === 0) {
+            Ec.waiting("🔍 未找到任何任务");
+            // 即使未找到任务也执行剪切板任务（使用默认值）
+            await _handleClipboardTask('default', [{ requirement: 'unknown' }]);
+            Ec.info("✅ 任务列表显示完成");
+            Ec.askClose();
+            process.exit(0);
+        }
+        
+        // 列出所有任务（包含路径）
+        Ec.waiting(`📊 共找到 ${tasks.length} 个任务:`);
+        tasks.forEach((task, index) => {
+            Ec.waiting(`${index + 1}. ${task.name}, ${task.path}`);
+        });
+        
+        // 执行剪切板任务（使用第一个任务）
+        await _handleClipboardTask(tasks[0].name, [tasks[0]]);
+        Ec.info("✅ 任务列表显示完成");
+        Ec.askClose();
+        process.exit(0);
+    } catch (error) {
+        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        Ec.askClose();
+        process.exit(1);
+    }
+};

package/src/executor/executeUnlock.js

@@ -0,0 +1,110 @@
+const Ec = require('../epic');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 删除 specification 目录下的所有任务锁文件
+ * @param {string} dir specification 目录路径
+ * @returns {number} 删除的文件数量
+ */
+const _unlockSpecification = (dir) => {
+    let deletedCount = 0;
+    
+    if (!fs.existsSync(dir)) {
+        return deletedCount;
+    }
+    
+    // 递归查找 specification/changes/*/tasks/*.lock 文件
+    const changesDir = path.join(dir, 'changes');
+    if (fs.existsSync(changesDir) && fs.statSync(changesDir).isDirectory()) {
+        const requirements = fs.readdirSync(changesDir).filter(file => 
+            fs.statSync(path.join(changesDir, file)).isDirectory()
+        );
+        
+        requirements.forEach(requirement => {
+            const tasksDir = path.join(changesDir, requirement, 'tasks');
+            if (fs.existsSync(tasksDir) && fs.statSync(tasksDir).isDirectory()) {
+                const taskFiles = fs.readdirSync(tasksDir).filter(file => 
+                    file.endsWith('.lock')
+                );
+                
+                taskFiles.forEach(taskFile => {
+                    const taskFilePath = path.join(tasksDir, taskFile);
+                    try {
+                        fs.unlinkSync(taskFilePath);
+                        Ec.waiting(`🔓 已解锁任务: ${path.relative(process.cwd(), taskFilePath)}`);
+                        deletedCount++;
+                    } catch (error) {
+                        Ec.waiting(`⚠️ 无法解锁任务: ${path.relative(process.cwd(), taskFilePath)} - ${error.message}`);
+                    }
+                });
+            }
+        });
+    }
+    
+    return deletedCount;
+};
+
+/**
+ * 删除 source 目录下的工作空间锁文件
+ * @param {string} dir source 目录路径
+ * @returns {number} 删除的文件数量
+ */
+const _unlockSource = (dir) => {
+    let deletedCount = 0;
+    
+    if (!fs.existsSync(dir)) {
+        return deletedCount;
+    }
+    
+    // 只删除 source/*.lock 文件（工作空间锁文件）
+    const lockFiles = fs.readdirSync(dir).filter(file => 
+        file.endsWith('.lock')
+    );
+    
+    lockFiles.forEach(lockFile => {
+        const lockFilePath = path.join(dir, lockFile);
+        try {
+            fs.unlinkSync(lockFilePath);
+            Ec.waiting(`🔓 已解锁工作空间: ${path.relative(process.cwd(), lockFilePath)}`);
+            deletedCount++;
+        } catch (error) {
+            Ec.waiting(`⚠️ 无法解锁工作空间: ${path.relative(process.cwd(), lockFilePath)} - ${error.message}`);
+        }
+    });
+    
+    return deletedCount;
+};
+
+module.exports = (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+    
+    try {
+        Ec.waiting("🔍 正在查找并解锁所有.lock文件...");
+        
+        // 解锁specification目录下的任务锁文件
+        const specificationDir = path.resolve(process.cwd(), 'specification');
+        const specDeletedCount = _unlockSpecification(specificationDir);
+        
+        // 解锁source目录下的工作空间锁文件
+        const sourceDir = path.resolve(process.cwd(), 'source');
+        const sourceDeletedCount = _unlockSource(sourceDir);
+        
+        const totalDeletedCount = specDeletedCount + sourceDeletedCount;
+        
+        if (totalDeletedCount === 0) {
+            Ec.waiting("✅ 未找到任何.lock文件，无需解锁");
+        } else {
+            Ec.waiting(`✅ 共解锁 ${totalDeletedCount} 个文件`);
+        }
+        
+        Ec.info("🔓 解锁操作完成");
+        Ec.askClose();
+        process.exit(0);
+    } catch (error) {
+        Ec.error(`❌ 解锁过程中发生错误: ${error.message}`);
+        Ec.askClose();
+        process.exit(1);
+    }
+};

package/src/executor/executeValidate.js

@@ -0,0 +1,210 @@
+const fs = require('fs');
+const path = require('path');
+const Ec = require('../epic');
+
+/**
+ * 获取模板中的标题结构
+ * @param {string} templatePath 模板文件路径
+ * @returns {Array} 标题结构数组
+ */
+const _getTemplateStructure = (templatePath) => {
+    if (!fs.existsSync(templatePath)) {
+        throw new Error(`模板文件不存在: ${templatePath}`);
+    }
+
+    const content = fs.readFileSync(templatePath, 'utf8');
+    const lines = content.split('\n');
+    const headings = [];
+
+    lines.forEach(line => {
+        // 直接计算 # 符号数量确定层级
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            const title = headingMatch[2].trim();
+            // 移除标题中的占位符内容（如 [xxx]）
+            const cleanTitle = title.replace(/\[.*?\]/g, '').trim();
+            if (cleanTitle) {
+                headings.push({level, title: cleanTitle});
+            }
+        }
+    });
+
+    return headings;
+};
+
+/**
+ * 获取需求文件中的标题结构
+ * @param {string} filePath 需求文件路径
+ * @returns {Array} 标题结构数组
+ */
+const _getFileStructure = (filePath) => {
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`需求文件不存在: ${filePath}`);
+    }
+
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+    const headings = [];
+
+    lines.forEach(line => {
+        // 直接计算 # 符号数量确定层级
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            const title = headingMatch[2].trim();
+            headings.push({level, title});
+        }
+    });
+
+    return headings;
+};
+
+/**
+ * 构建完整的树型结构
+ * @param {Array} headings 标题数组
+ * @returns {Array} 树型结构
+ */
+const _buildTreeStructure = (headings) => {
+    const structure = [];
+    const stack = [];
+
+    headings.forEach(heading => {
+        const {level, title} = heading;
+
+        // 调整栈以匹配当前层级
+        while (stack.length >= level) {
+            stack.pop();
+        }
+
+        const item = {level, title, children: []};
+
+        if (stack.length > 0) {
+            stack[stack.length - 1].children.push(item);
+        } else {
+            structure.push(item);
+        }
+
+        stack.push(item);
+    });
+
+    return structure;
+};
+
+/**
+ * 打印树型结构
+ * @param {Array} items 结构项数组
+ * @param {number} indent 缩进级别
+ */
+const _printTree = (items, indent = 0) => {
+    items.forEach(item => {
+        const prefix = '  '.repeat(indent);
+        Ec.waiting(`${prefix}├─ ${item.title}`);
+
+        if (item.children && item.children.length > 0) {
+            _printTree(item.children, indent + 1);
+        }
+    });
+};
+
+/**
+ * 打印带高亮的树型结构
+ * @param {Array} items 结构项数组
+ * @param {Set} missingTitles 缺失的标题集合
+ * @param {number} indent 缩进级别
+ */
+const _printTreeWithHighlight = (items, missingTitles, indent = 0) => {
+    items.forEach(item => {
+        const prefix = '  '.repeat(indent);
+        if (missingTitles.has(item.title)) {
+            // 缺失的章节用红色高亮并添加emoji标识
+            Ec.error(`${prefix}├─ ❌ ${item.title}`);
+        } else {
+            // 正常章节用白色显示
+            Ec.waiting(`${prefix}├─ ${item.title}`);
+        }
+
+        if (item.children && item.children.length > 0) {
+            _printTreeWithHighlight(item.children, missingTitles, indent + 1);
+        }
+    });
+};
+
+/**
+ * 查找缺失的章节
+ * @param {Array} templateStructure 模板结构
+ * @param {Array} fileStructure 文件结构
+ * @returns {Array} 缺失的章节列表
+ */
+const _findMissingSections = (templateStructure, fileStructure) => {
+    const templateTitles = templateStructure.map(item => item.title);
+    const fileTitles = fileStructure.map(item => item.title);
+
+    // 找出在模板中存在但在文件中缺失的章节
+    return templateStructure.filter(item =>
+        !fileTitles.includes(item.title)
+    );
+};
+
+module.exports = (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+    const requirementName = parsed.name || parsed.n;
+
+    // 验证参数
+    if (!requirementName) {
+        Ec.error("❌ 请提供需求名称 (-n, --name)");
+        process.exit(1);
+    }
+
+    try {
+        // 构建路径
+        const projectDir = process.cwd();
+        const changesDir = path.join(projectDir, 'specification', 'changes');
+        const requirementDir = path.join(changesDir, requirementName);
+        const proposalFile = path.join(requirementDir, 'proposal.md');
+        const templateFile = path.join(__dirname, '../_template/LAIN/changes/proposal.md');
+
+        // 检查需求目录是否存在
+        if (!fs.existsSync(requirementDir)) {
+            Ec.error(`❌ 需求 "${requirementName}" 不存在`);
+            process.exit(1);
+        }
+
+        // 检查 proposal.md 文件是否存在
+        if (!fs.existsSync(proposalFile)) {
+            Ec.error(`❌ 需求 "${requirementName}" 中未找到 proposal.md 文件`);
+            process.exit(1);
+        }
+
+        // 获取模板和文件的结构
+        const templateStructure = _getTemplateStructure(templateFile);
+        const fileStructure = _getFileStructure(proposalFile);
+
+        // 查找缺失的章节
+        const missingSections = _findMissingSections(templateStructure, fileStructure);
+
+        // 构建模板的树型结构
+        const templateTree = _buildTreeStructure(templateStructure);
+
+        if (missingSections.length === 0) {
+            Ec.info(`✅ 需求 "${requirementName}" 格式验证通过`);
+            process.exit(0);
+        } else {
+            Ec.waiting(`需求名称: ${requirementName}`);
+            Ec.waiting('文档结构验证结果:');
+
+            // 创建缺失标题的集合
+            const missingTitles = new Set(missingSections.map(section => section.title));
+
+            // 以模板结构为基准打印树型结构，并高亮缺失的章节
+            _printTreeWithHighlight(templateTree, missingTitles);
+
+            Ec.error(`\n❌ 需求 "${requirementName}" 格式验证失败，缺失 ${missingSections.length} 个章节`);
+            process.exit(1);
+        }
+    } catch (error) {
+        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        process.exit(1);
+    }
+};

package/src/executor/index.js

@@ -0,0 +1,35 @@
+const executeHelp = require('./executeHelp');
+const executeInit = require('./executeInit');
+const executeRepo = require('./executeRepo');
+const executeAdd = require('./executeAdd');
+const executePlan = require('./executePlan');
+const executeArchive = require('./executeArchive');
+const executeEnv = require('./executeEnv');
+const executeOpen = require('./executeOpen');
+const executeShow = require('./executeShow');
+const executeList = require('./executeList');
+const executeValidate = require('./executeValidate');
+const executeActor = require('./executeActor');
+const executeActors = require('./executeActors');
+const executeRun = require('./executeRun');
+const executeTasks = require('./executeTasks');
+const executeUnlock = require('./executeUnlock');
+const exported = {
+    executeHelp,
+    executeInit,
+    executeRepo,
+    executeAdd,
+    executePlan,
+    executeArchive,
+    executeEnv,
+    executeOpen,
+    executeShow,
+    executeList,
+    executeValidate,
+    executeActor,
+    executeActors,
+    executeRun,
+    executeTasks,
+    executeUnlock
+};
+module.exports = exported;

package/src/momo.js

@@ -1 +1,39 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
+const Ec = require('./epic');
+const Executor = require('./executor');
+const path = require('path');
+const fs = require('fs');
+
+// 检查是否是 version 命令模式
+const _isVersionMode = () => {
+    const args = process.argv.slice(2);
+    return args.includes('version') || args.includes('-v') || args.includes('--version');
+};
+
+// 获取项目版本号
+const _getVersion = () => {
+    try {
+        const packagePath = path.resolve(__dirname, '../package.json');
+        const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+        return packageJson.version || '未知版本';
+    } catch (error) {
+        return '未知版本';
+    }
+};
+
+// 如果是 version 命令，则只输出版本号并退出
+if (_isVersionMode()) {
+    console.log(_getVersion());
+    process.exit(0);
+}
+
+// 输出头部
+Ec.executeHeader("Rachel Momo / SDD");
+
+// 读取配置文件
+const configArr = Ec.parseMetadata();
+Ec.executeBody(configArr, Executor);
+
+
+// 输出尾部
+Ec.executeEnd();

package/.idea/copilot.data.migration.agent.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="AgentMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/copilot.data.migration.ask.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="AskMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/copilot.data.migration.ask2agent.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="Ask2AgentMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/copilot.data.migration.edit.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="EditMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/r2mo-lain.iml" filepath="$PROJECT_DIR$/.idea/r2mo-lain.iml" />
-    </modules>
-  </component>
-</project>