momo-ai 1.0.5 → 1.0.7

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,11 @@ 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 executeConsole = require('./executeConsole');
+
 const exported = {
     executeHelp,
     executeInit,
@@ -30,6 +35,10 @@ const exported = {
     executeActors,
     executeRun,
     executeTasks,
-    executeUnlock
+    executeUnlock,
+    executeProject,
+    executeAgentCfg,
+    executeAgent,
+    executeConsole
 };
 module.exports = exported;

package/src/lain.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+/**
+ * Lain Console - 独立的交互式控制台入口
+ */
+
+const readline = require('readline');
+const colors = require('colors');
+const path = require('path');
+const fs = require('fs');
+const terminalCommands = require('./terminal');
+
+// 设置颜色主题
+colors.setTheme({
+    silly: 'rainbow',
+    input: 'grey',
+    verbose: 'cyan',
+    prompt: 'red',
+    info: 'green',
+    data: 'blue',
+    help: 'cyan',
+    warn: 'yellow',
+    debug: 'magenta',
+    error: 'red'
+});
+
+// 显示欢迎界面和菜单
+const showMenu = () => {
+    // 清屏
+    process.stdout.write('\x1Bc');
+    
+    // 显示标准头部信息
+    showHeader();
+    
+    // 使用96个字符宽度
+    const width = 96;
+    const headerBorder = '='.repeat(width).blue;
+    const footerBorder = '-'.repeat(width).blue;
+    
+    console.log('');
+    console.log(headerBorder);
+    const title = 'Momo AI / Lain Console';
+    const padding = ' '.repeat(Math.floor((width - title.length) / 2) - 1);
+    console.log(`${padding}${title}`.bold.brightCyan);
+    console.log(headerBorder);
+    
+    console.log('');
+    console.log('欢迎使用 Momo AI / Lain 控制台！'.green);
+    console.log('这是一个交互式命令行界面。'.yellow);
+    console.log('');
+    
+    console.log('可用命令：'.bold);
+    console.log('  help     - 显示帮助信息'.white);
+    console.log('  test     - 执行测试命令'.white);
+    console.log('  llm      - 查看大模型配置信息'.white);
+    console.log('  quit     - 退出控制台'.white);
+    console.log('');
+    
+    console.log('请在提示符后输入命令。'.gray);
+    console.log(footerBorder);
+};
+
+// 显示标准头部信息
+const showHeader = () => {
+    const appInfo = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../package.json'), 'utf8'));
+    
+    console.log(`[Momo AI]`.green.bold + ` ----------------- Rachel Momo / AI工具项  ------------------`.rainbow);
+    console.log(`[Momo AI]`.green.bold + ' 应用名称: '.bold + 'Rachel Momo / SDD');
+    console.log(`[Momo AI]`.green.bold + ' 工具主页: '.bold + appInfo.homepage.blue);
+    console.log(`[Momo AI]`.green.bold + ` 工具版本: ` + `${appInfo.version}`.red + '  ' + `( Node >= 22.x )`.yellow);
+    console.log(`[Momo AI]`.green.bold);
+    console.log(`[Momo AI]`.green.bold + ` ----------------- AI 系统启动…… ----------------------------`.rainbow);
+};
+
+// 处理用户输入
+const handleInput = (input, commands) => {
+    const command = input.trim().toLowerCase();
+    
+    // 创建命令上下文
+    const context = {
+        commands: commands
+    };
+    
+    switch (command) {
+        case '':
+            // 空命令，不处理
+            break;
+        case 'help':
+            commands.help(context);
+            break;
+        case 'test':
+            commands.test(context);
+            break;
+        case 'llm':
+            commands.llm(context);
+            break;
+        case 'quit':
+            commands.quit(context);
+            break;
+        default:
+            console.log('');
+            console.log(`未知命令: ${command}`.brightRed);
+            console.log('输入 "help" 查看可用命令。'.yellow);
+            console.log('');
+    }
+};
+
+// 主函数
+const main = async () => {
+    showMenu();
+    
+    // 创建 readline 接口
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: '[Lain AI] > '.cyan.bold
+    });
+    
+    rl.prompt();
+    
+    rl.on('line', (line) => {
+        const input = line.trim();
+        handleInput(input, terminalCommands);
+        rl.prompt();
+    }).on('close', () => {
+        console.log('\n' + '感谢使用 Momo AI / Lain 控制台，再见！'.brightGreen + '\n');
+        process.exit(0);
+    });
+    
+    // 处理 Ctrl+C
+    process.on('SIGINT', () => {
+        console.log('\n\n' + '感谢使用 Momo AI / Lain 控制台，再见！'.brightGreen + '\n');
+        rl.close();
+        process.exit(0);
+    });
+};
+
+// 启动程序
+main().catch(err => {
+    console.error('启动控制台时出错:', err);
+    process.exit(1);
+});

package/src/terminal/commandHelp.js

@@ -0,0 +1,16 @@
+/**
+ * Help command implementation
+ */
+
+const helpCommand = (context) => {
+    console.log('');
+    console.log('帮助信息：'.bold.brightYellow);
+    
+    console.log('  help     - 显示此帮助信息'.white);
+    console.log('  test     - 执行测试命令'.white);
+    console.log('  llm      - 查看大模型配置信息'.white);
+    console.log('  quit     - 退出控制台'.white);
+    console.log('');
+};
+
+module.exports = helpCommand;