momo-ai 1.0.19 → 1.0.21

package/src/executor/executeShow.js

@@ -1,164 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const Ec = require('../epic');
-
-/**
- * 解析 Markdown 文件内容，提取标题结构
- * @param {string} content 文件内容
- * @returns {Array} 标题结构数组
- */
-const _parseMarkdownStructure = (content) => {
-    const lines = content.split('\n');
-    const structure = [];
-    const stack = [];
-    
-    lines.forEach(line => {
-        const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
-        if (headingMatch) {
-            const level = headingMatch[1].length;
-            const title = headingMatch[2].trim();
-            
-            // 调整栈以匹配当前层级
-            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 {string} tasksFile 任务文件路径
- * @returns {Array} 任务列表
- */
-const _extractTaskList = (tasksFile) => {
-    const tasks = [];
-    
-    try {
-        if (!fs.existsSync(tasksFile)) {
-            return tasks;
-        }
-        
-        const content = fs.readFileSync(tasksFile, 'utf8');
-        const lines = content.split('\n');
-        
-        // 使用与 executeList.js 相同的逻辑来匹配任务
-        for (const line of lines) {
-            // 匹配任务格式，例如: - [ ] [任务1简要描述](tasks/M01-T001-01.md)
-            if (line.trim().startsWith('- [') && line.includes('] [') && line.includes('](') && line.includes('tasks/')) {
-                // 提取任务描述部分，使用更兼容的正则表达式
-                const titleMatch = line.match(/] $$(.*?)$$$(tasks\/)/);
-                if (titleMatch) {
-                    // 获取标题和链接
-                    const fullMatch = line.match(/] $$(.*?)$$$(tasks\/[^)]+)$/);
-                    if (fullMatch) {
-                        tasks.push({
-                            title: fullMatch[1],
-                            link: fullMatch[2]
-                        });
-                    }
-                } else {
-                    // 备用方案：简单提取方括号中的内容
-                    const simpleMatch = line.match(/\[([^\]]+)\]/g);
-                    if (simpleMatch && simpleMatch.length >= 2) {
-                        tasks.push({
-                            title: simpleMatch[1].substring(1, simpleMatch[1].length - 1),
-                            link: ''
-                        });
-                    }
-                }
-            }
-        }
-    } catch (error) {
-        // 忽略错误，返回空任务列表
-    }
-    
-    return tasks;
-};
-
-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);
-        
-        // 检查需求目录是否存在
-        if (!fs.existsSync(requirementDir)) {
-            Ec.error(`❌ 需求 "${requirementName}" 不存在`);
-            process.exit(1);
-        }
-        
-        // 读取 proposal.md 文件
-        const proposalFile = path.join(requirementDir, 'proposal.md');
-        if (!fs.existsSync(proposalFile)) {
-            Ec.error(`❌ 需求 "${requirementName}" 中未找到 proposal.md 文件`);
-            process.exit(1);
-        }
-        
-        const content = fs.readFileSync(proposalFile, 'utf8');
-        
-        // 解析并显示结构
-        Ec.waiting(`需求名称: ${requirementName}`);
-        Ec.waiting('文档结构:');
-        const structure = _parseMarkdownStructure(content);
-        _printTree(structure);
-        
-        // 提取并显示任务清单
-        const tasksFile = path.join(requirementDir, 'tasks.md');
-        const tasks = _extractTaskList(tasksFile);
-        
-        Ec.waiting(`\n任务清单 (共${tasks.length}个任务):`);
-        if (tasks.length > 0) {
-            tasks.forEach((task, index) => {
-                Ec.waiting(`  ${index + 1}. ${task.title}`);
-            });
-        } else {
-            Ec.waiting('  无');
-        }
-        
-        Ec.info('✅ 需求详情显示完成');
-        process.exit(0);
-    } catch (error) {
-        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
-        process.exit(1);
-    }
-};

package/src/executor/executeTasks.js

@@ -1,384 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const util = require('util');
-const Ec = require('../epic');
-const fsAsync = require('fs').promises;
-const { outCopy } = require('../epic/momo.fn.out');
-
-/**
- * 读取模板文件并提取 <!-- 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 {
-        // 使用统一的剪贴板函数
-        await outCopy(content);
-        Ec.waiting('📄 任务检查提示词已拷贝到剪切板');
-    } catch (error) {
-        Ec.waiting(`⚠️  无法拷贝到剪切板: ${error.message}`);
-        // 备选方案：显示内容
-        Ec.waiting('提示词内容:');
-        console.log(content);
-        if (process.platform === 'win32') {
-            Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
-        }
-    }
-};
-
-/**
- * 从 Markdown 文件中提取第一个标题
- * @param {string} filePath 文件路径
- * @returns {string} 第一个标题内容
- */
-const _extractTitleFromMarkdown = (filePath) => {
-    try {
-        if (!fs.existsSync(filePath)) {
-            return path.basename(filePath, '.md');
-        }
-        
-        const content = fs.readFileSync(filePath, 'utf8');
-        const lines = content.split('\n');
-        
-        for (const line of lines) {
-            // 匹配 # 开头的标题行
-            const titleMatch = line.match(/^#\s+(.+)$/);
-            if (titleMatch) {
-                return titleMatch[1].trim();
-            }
-        }
-        
-        // 如果没有找到标题，使用文件名（不含扩展名）作为任务名称
-        return path.basename(filePath, '.md');
-    } catch (error) {
-        return path.basename(filePath, '.md');
-    }
-};
-
-/**
- * 检查任务状态
- * @param {string} taskName 任务名称
- * @param {string} tasksDir 任务目录
- * @returns {string} 任务状态
- */
-const _checkTaskStatus = (taskName, tasksDir) => {
-    // 检查.lock文件（进行中）
-    const lockFile = path.join(tasksDir, `${taskName}.lock`);
-    if (fs.existsSync(lockFile)) {
-        return '进行中';
-    }
-
-    // 检查.done文件（已完成）
-    const doneFile = path.join(tasksDir, `${taskName}.done`);
-    if (fs.existsSync(doneFile)) {
-        return '已完成';
-    }
-
-    // 默认状态（未开始）
-    return '未开始';
-};
-
-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);
-        }
-        
-        // 如果指定了任务名称，只检查该任务的重复信息
-        if (taskName) {
-            const taskInstances = [];
-            
-            // 查找指定任务
-            requirements.forEach(requirement => {
-                const tasksDir = path.resolve(changesDir, requirement, 'tasks');
-                
-                // 检查 tasks 目录是否存在
-                if (fs.existsSync(tasksDir) && fs.statSync(tasksDir).isDirectory()) {
-                    // 检查 .md 文件
-                    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
-                        });
-                    }
-                    
-                    // 检查 .done 文件（如果 .md 文件不存在）
-                    const doneFile = `${taskName}.done`;
-                    const donePath = path.resolve(tasksDir, doneFile);
-                    
-                    if (!fs.existsSync(taskPath) && fs.existsSync(donePath)) {
-                        const relativePath = path.relative(process.cwd(), donePath);
-                        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(`   ${String(index + 1).padStart(3, '0')}. ${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 mdFiles = fs.readdirSync(tasksDir).filter(file => 
-                    file.endsWith('.md')
-                );
-                
-                // 获取所有 .done 文件
-                const doneFiles = fs.readdirSync(tasksDir).filter(file => 
-                    file.endsWith('.done')
-                );
-                
-                // 处理 .md 文件
-                mdFiles.forEach(taskFile => {
-                    const name = path.basename(taskFile, '.md');
-                    const taskPath = path.relative(process.cwd(), path.resolve(tasksDir, taskFile));
-                    const title = _extractTitleFromMarkdown(path.resolve(tasksDir, taskFile));
-                    const status = _checkTaskStatus(name, tasksDir);
-                    
-                    // 为状态添加颜色代码
-                    let coloredStatus;
-                    switch (status) {
-                        case '进行中':
-                            coloredStatus = status.blue;
-                            break;
-                        case '已完成':
-                            coloredStatus = status.green;
-                            break;
-                        case '未开始':
-                            coloredStatus = status.red;
-                            break;
-                        default:
-                            coloredStatus = status;
-                    }
-                    
-                    tasks.push({
-                        name: name,
-                        title: title,
-                        path: taskPath,
-                        requirement: requirement,
-                        status: coloredStatus
-                    });
-                });
-                
-                // 处理 .done 文件（但没有对应的 .md 文件）
-                doneFiles.forEach(doneFile => {
-                    const name = path.basename(doneFile, '.done');
-                    // 检查是否已经有对应的 .md 文件在任务列表中
-                    const hasMdFile = mdFiles.some(mdFile => 
-                        path.basename(mdFile, '.md') === name
-                    );
-                    
-                    // 如果没有对应的 .md 文件，则添加到任务列表
-                    if (!hasMdFile) {
-                        const donePath = path.relative(process.cwd(), path.resolve(tasksDir, doneFile));
-                        // 尝试从 .done 文件中提取标题，如果失败则使用文件名
-                        let title = _extractTitleFromMarkdown(path.resolve(tasksDir, `${name}.md`));
-                        // 如果从 .md 文件提取失败，则尝试从 .done 文件提取
-                        if (title === name) {
-                            title = _extractTitleFromMarkdown(path.resolve(tasksDir, doneFile));
-                        }
-                        // 使用标准的状态检查函数
-                        const status = _checkTaskStatus(name, tasksDir);
-                        // 为状态添加颜色代码
-                        let coloredStatus;
-                        switch (status) {
-                            case '进行中':
-                                coloredStatus = status.blue;
-                                break;
-                            case '已完成':
-                                coloredStatus = status.green;
-                                break;
-                            case '未开始':
-                                coloredStatus = status.red;
-                                break;
-                            default:
-                                coloredStatus = status;
-                        }
-                        
-                        tasks.push({
-                            name: name,
-                            title: title,
-                            path: donePath,
-                            requirement: requirement,
-                            status: coloredStatus
-                        });
-                    }
-                });
-
-            }
-        });
-        
-        // 按任务名称排序
-        tasks.sort((a, b) => a.name.localeCompare(b.name));
-        
-        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) => {
-            const paddedIndex = String(index + 1).padStart(3, '0');
-            const coloredName = task.name.cyan;
-            const coloredPath = task.path.yellow;  // 使用黄色高亮路径
-            
-            Ec.waiting(`${paddedIndex}. ${coloredName} [${task.status}] | ${task.title} / ${coloredPath}`);
-        });
-        
-        // 执行剪切板任务（使用第一个任务）
-        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);
-    }
-};
-
-/**
- * 处理剪切板任务
- * @param {string} taskName 任务名称
- * @param {Array} taskInstances 任务实例列表
- */
-const _handleClipboardTask = async (taskName, taskInstances) => {
-    // 读取模板文件并填充参数，然后拷贝到剪贴板
-    const templatePath = path.resolve(__dirname, '../_template/PROMPT/tasks.md.ejs');
-    
-    if (fs.existsSync(templatePath)) {
-        try {
-            // 读取并处理提示词模板
-            const templateContent = await _readTemplate(templatePath);
-            
-            const renderedContent = _renderTemplate(templateContent, { 
-                REQ: taskInstances[0].requirement,
-                TASK: taskName
-            });
-            
-            // 将提示词复制到剪贴板
-            await _copyToClipboard(renderedContent);
-        } catch (error) {
-            Ec.waiting(`⚠️  处理模板时出错: ${error.message}`);
-        }
-    } else {
-        Ec.waiting(`⚠️  未找到模板文件: ${templatePath}`);
-    }
-};

package/src/executor/executeUnlock.js

@@ -1,110 +0,0 @@
-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);
-    }
-};