yuangs 1.3.34 → 1.3.37

package/cli.js

@@ -2,11 +2,43 @@
 
 const yuangs = require('./index.js');
 const chalk = require('chalk');
-const { version } = require('./package.json'); // 引入版本号
+const { version } = require('./package.json');
+const fs = require('fs');
+const path = require('path');
+const ora = require('ora').default;
+const { marked } = require('marked');
+const TerminalRenderer = require('marked-terminal').default;
+const { exec } = require('child_process');
+
+marked.setOptions({
+    renderer: new TerminalRenderer({
+        code: chalk.yellow,
+        heading: chalk.magenta.bold,
+        firstHeading: chalk.magenta.underline.bold,
+        listitem: chalk.cyan,
+        table: chalk.white,
+        strong: chalk.bold.red,
+        em: chalk.italic
+    })
+});
 
 const args = process.argv.slice(2);
 const command = args[0];
 
+async function readStdin() {
+    if (process.stdin.isTTY) return '';
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on('end', () => {
+            resolve(data);
+        });
+    });
+}
+
 function printHelp() {
     console.log(chalk.bold.cyan('\n🎨 苑广山的个人应用启动器\n'));
     console.log(chalk.yellow(`当前版本: ${version}`)); // 显示版本号
@@ -35,6 +67,11 @@ function printHelp() {
     console.log(`    ${chalk.gray('--model, -m <模型名称>')}  指定 AI 模型 (可选)`);
     console.log(`    ${chalk.gray('-p -f -l')}  指定 pro,flash,lite 模型 (可选)`);
     console.log(`    ${chalk.gray('-e <描述>')}         生成 Linux 命令`);
+    console.log(`  ${chalk.green('config')} <key> <value>  设置配置项`);
+    console.log(`  ${chalk.green('history')}           查看命令历史`);
+    console.log(`  ${chalk.green('save')} <名称>         创建快捷指令`);
+    console.log(`  ${chalk.green('run')} <名称>          执行快捷指令`);
+    console.log(`  ${chalk.green('macros')}            查看所有快捷指令`);
     console.log(`  ${chalk.green('help')}              显示帮助信息\n`);
     console.log(chalk.bold('AI 交互模式命令:'));
     console.log(`    ${chalk.gray('/clear')}           清空对话历史`);
@@ -51,50 +88,83 @@ function printSuccess(app, url) {
 }
 
 async function askOnce(question, model) {
-    const startTime = Date.now(); // Record start time
+    const startTime = Date.now();
     let i = 0;
     const spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
     const interval = setInterval(() => {
-        const elapsedTime = Math.floor((Date.now() - startTime) / 1000); // Calculate elapsed time in seconds
+        const elapsedTime = Math.floor((Date.now() - startTime) / 1000);
         process.stdout.write(chalk.cyan(`\r${spinner[i++ % spinner.length]} 正在请求 AI，请稍候... (${elapsedTime}s}`));
     }, 100);
 
     try {
-        // For single requests (non-interactive mode), we may want to include history
-        // For now, use history for all requests, but we could make this configurable
         const answer = await yuangs.getAIAnswer(question, model, true);
         clearInterval(interval);
 
-        // Clear the spinner line if possible
         if (process.stdout.clearLine) {
             process.stdout.clearLine(0);
             process.stdout.cursorTo(0);
         } else {
-            process.stdout.write('\r'); // Fallback to just carriage return
+            process.stdout.write('\r');
         }
 
-        const totalElapsedTime = (Date.now() - startTime) / 1000; // Calculate total elapsed time
+        const totalElapsedTime = (Date.now() - startTime) / 1000;
         if (answer && answer.explanation) {
-            console.log(chalk.bold.green('🤖 AI 回答:\n'));
-            console.log(answer.explanation);
+            console.log(marked(answer.explanation));
         } else {
             console.log(chalk.yellow('AI 未返回有效内容。'));
         }
-        console.log(chalk.gray(`\n请求耗时: ${totalElapsedTime.toFixed(2)}s\n`)); // Display total elapsed time
+        console.log(chalk.gray(`\n请求耗时: ${totalElapsedTime.toFixed(2)}s\n`));
     } catch (error) {
         clearInterval(interval);
 
-        // Clear the spinner line if possible
         if (process.stdout.clearLine) {
             process.stdout.clearLine(0);
             process.stdout.cursorTo(0);
         } else {
-            process.stdout.write('\r'); // Fallback to just carriage return
+            process.stdout.write('\r');
         }
 
-        const totalElapsedTime = (Date.now() - startTime) / 1000; // Calculate total elapsed time on error
+        const totalElapsedTime = (Date.now() - startTime) / 1000;
         console.error(chalk.red('处理 AI 请求时出错:'), error.message || error);
-        console.log(chalk.gray(`\n请求耗时: ${totalElapsedTime.toFixed(2)}s\n`)); // Display total elapsed time on error
+        console.log(chalk.gray(`\n请求耗时: ${totalElapsedTime.toFixed(2)}s\n`));
+    }
+}
+
+async function askOnceStream(question, model) {
+    const startTime = Date.now();
+    let messages = [...yuangs.getConversationHistory()];
+    messages.push({ role: 'user', content: question });
+
+    const spinner = ora(chalk.cyan('AI 正在思考...')).start();
+    let fullResponse = '';
+    let firstChunk = true;
+
+    const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+    try {
+        await yuangs.callAI_Stream(messages, model, (chunk) => {
+            if (spinner.isSpinning) {
+                spinner.stop();
+            }
+            fullResponse += chunk;
+            process.stdout.write(chunk);
+        });
+
+        yuangs.addToConversationHistory('user', question);
+        yuangs.addToConversationHistory('assistant', fullResponse);
+
+        // 打印优美的分割线和 Markdown 渲染结果
+        console.log('');
+        console.log(chalk.gray('─'.repeat(Math.min(80, process.stdout.columns || 80))));
+        console.log(marked(fullResponse));
+
+        const totalElapsedTime = (Date.now() - startTime) / 1000;
+        console.log(chalk.gray(`\n\n请求耗时: ${totalElapsedTime.toFixed(2)}s\n`));
+    } catch (error) {
+        if (spinner.isSpinning) {
+            spinner.fail(chalk.red('AI 响应出错'));
+        }
+        console.error(error.message);
     }
 }
 
@@ -105,6 +175,12 @@ async function handleAICommand() {
     let questionParts = commandArgs;
     let isExecMode = false;
 
+    const stdinContent = await readStdin();
+
+    if (stdinContent) {
+        questionParts.unshift(stdinContent);
+    }
+
     // Check for -e flag
     const execIndex = commandArgs.indexOf('-e');
     if (execIndex !== -1) {
@@ -218,11 +294,13 @@ async function handleAICommand() {
 
                 const { spawn } = require('child_process');
                 console.log(chalk.gray('正在执行...'));
-                // Use shell: true to support pipes, redirects, etc.
                 const child = spawn(finalCommand, [], { shell: true, stdio: 'inherit' });
 
                 child.on('close', (code) => {
-                    if (code !== 0) {
+                    if (code === 0) {
+                        yuangs.saveSuccessfulCommand(question, finalCommand);
+                        console.log(chalk.green('\n✓ 执行成功并已存入历史库'));
+                    } else {
                         console.log(chalk.red(`\n命令执行失败 (退出码: ${code})`));
                     }
                     process.exit(code);
@@ -288,11 +366,10 @@ async function handleAICommand() {
                 }
 
                 if (!trimmed) {
-                    return askLoop(); // 空输入则重新询问
+                    return askLoop();
                 }
 
-                // 等待回答完成后，再开启下一轮询问
-                await askOnce(trimmed, model);
+                await askOnceStream(trimmed, model);
                 askLoop();
             });
         };
@@ -303,7 +380,7 @@ async function handleAICommand() {
     }
 
     // 有问题时，直接请求一次
-    await askOnce(question, model);
+    await askOnceStream(question, model);
 }
 
 // Check if the command matches one of the configured apps
@@ -333,13 +410,143 @@ switch (command) {
     case 'ai':
         handleAICommand();
         break;
+    case 'config':
+        const key = args[1];
+        const value = args[2];
+        if (!key || !value) {
+            console.log(chalk.cyan('\n⚙️  配置帮助: yuangs config <key> <value>'));
+            console.log(chalk.gray('当前配置:'), yuangs.getUserConfig());
+            console.log(chalk.gray('\n可用配置:'));
+            console.log(chalk.gray('  defaultModel  默认AI模型 (如: Assistant, gemini-pro-latest)'));
+            console.log(chalk.gray('  aiProxyUrl    AI代理地址'));
+            console.log(chalk.gray('  accountType   账户类型 (如: free, pro)\n'));
+            break;
+        }
+        const config = yuangs.getUserConfig();
+        config[key] = value;
+        fs.writeFileSync(path.join(require('os').homedir(), '.yuangs.json'), JSON.stringify(config, null, 2));
+        console.log(chalk.green(`✓ 已更新 ${key}`));
+        break;
+    case 'history':
+        const history = yuangs.getCommandHistory();
+        if (history.length === 0) {
+            console.log(chalk.gray('暂无命令历史\n'));
+        } else {
+            console.log(chalk.bold.cyan('\n📋 命令历史\n'));
+            console.log(chalk.gray('─────────────────────────────────────────────────'));
+            history.forEach((item, index) => {
+                console.log(chalk.white(`${index + 1}. ${item.command}`));
+                console.log(chalk.gray(`   问题: ${item.question}`));
+                console.log(chalk.gray(`   时间: ${item.time}\n`));
+            });
+            console.log(chalk.gray('─────────────────────────────────────────────────\n'));
+        }
+        break;
+    case 'save':
+        const macroName = args[1];
+        if (!macroName) {
+            console.log(chalk.red('\n错误: 请指定快捷指令名称'));
+            console.log(chalk.gray('用法: yuangs save <名称>\n'));
+            break;
+        }
+
+        const readline = require('readline');
+        const saveRl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        console.log(chalk.cyan(`\n正在创建快捷指令 "${macroName}"...`));
+        console.log(chalk.gray('请输入要保存的命令（多行命令用 && 或 ; 分隔，输入空行结束）:\n'));
+
+        let commandLines = [];
+        const askCommand = () => {
+            saveRl.question(chalk.green('> '), (line) => {
+                if (line.trim() === '') {
+                    if (commandLines.length === 0) {
+                        console.log(chalk.yellow('\n未输入命令，已取消'));
+                        saveRl.close();
+                        return;
+                    }
+
+                    saveRl.question(chalk.cyan('请输入描述（可选）: '), (desc) => {
+                        const commands = commandLines.map(cmd => cmd.trim()).join(' && ');
+                        yuangs.saveMacro(macroName, commands, desc.trim());
+                        console.log(chalk.green(`\n✓ 快捷指令 "${macroName}" 已保存\n`));
+                        saveRl.close();
+                    });
+                    return;
+                }
+                commandLines.push(line);
+                askCommand();
+            });
+        };
+        askCommand();
+        break;
+    case 'run':
+        const runMacroName = args[1];
+        if (!runMacroName) {
+            console.log(chalk.red('\n错误: 请指定快捷指令名称'));
+            console.log(chalk.gray('用法: yuangs run <名称>\n'));
+            break;
+        }
+
+        const macros = yuangs.getMacros();
+        if (!macros[runMacroName]) {
+            console.log(chalk.red(`\n错误: 快捷指令 "${runMacroName}" 不存在`));
+            console.log(chalk.gray('使用 "yuangs macros" 查看所有快捷指令\n'));
+            break;
+        }
+
+        const macro = macros[runMacroName];
+        console.log(chalk.cyan(`\n执行快捷指令: ${runMacroName}`));
+        if (macro.description) {
+            console.log(chalk.gray(`描述: ${macro.description}`));
+        }
+        console.log(chalk.gray(`命令: ${macro.commands}\n`));
+
+        const { spawn } = require('child_process');
+        const child = spawn(macro.commands, [], { shell: true, stdio: 'inherit' });
+
+        child.on('close', (code) => {
+            if (code !== 0) {
+                console.error(chalk.red(`\n快捷指令执行失败 (退出码: ${code})`));
+                process.exit(code);
+            }
+        });
+        break;
+    case 'macros':
+        const allMacros = yuangs.getMacros();
+        const macroNames = Object.keys(allMacros);
+
+        if (macroNames.length === 0) {
+            console.log(chalk.gray('暂无快捷指令\n'));
+            console.log(chalk.gray('使用 "yuangs save <名称>" 创建快捷指令\n'));
+            break;
+        }
+
+        console.log(chalk.bold.cyan('\n🚀 快捷指令列表\n'));
+        console.log(chalk.gray('─────────────────────────────────────────────────'));
+        macroNames.forEach(name => {
+            const m = allMacros[name];
+            console.log(chalk.white(`  ${name}`));
+            if (m.description) {
+                console.log(chalk.gray(`    描述: ${m.description}`));
+            }
+            console.log(chalk.gray(`    命令: ${m.commands}`));
+            console.log('');
+        });
+        console.log(chalk.gray('─────────────────────────────────────────────────\n'));
+        console.log(chalk.gray('使用:'));
+        console.log(chalk.gray('  yuangs run <名称>  执行快捷指令'));
+        console.log(chalk.gray('  yuangs save <名称>  创建新快捷指令\n'));
+        break;
     case 'help':
     case '--help':
     case '-h':
         printHelp();
         break;
     default:
-        // If it's an app command but not one of the named ones, handle it with the dynamic function
         if (isAppCommand) {
             printSuccess(command, yuangs.urls[command]);
             yuangs.openApp(command);

package/index.js

@@ -2,11 +2,72 @@ const { exec } = require('child_process');
 const axios = require('axios');
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 
 // Store conversation history
 // 存储结构标准为: [{ role: 'user', content: '...' }, { role: 'assistant', content: '...' }]
 let conversationHistory = [];
 
+const HISTORY_FILE = path.join(os.homedir(), '.yuangs_cmd_history.json');
+const CONFIG_FILE = path.join(os.homedir(), '.yuangs.json');
+const MACROS_FILE = path.join(os.homedir(), '.yuangs_macros.json');
+
+function getUserConfig() {
+    if (fs.existsSync(CONFIG_FILE)) {
+        try {
+            return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+        } catch (e) {}
+    }
+    return {};
+}
+
+function getCommandHistory() {
+    if (fs.existsSync(HISTORY_FILE)) {
+        try {
+            return JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf8'));
+        } catch (e) {}
+    }
+    return [];
+}
+
+function saveSuccessfulCommand(question, command) {
+    if (!command) return;
+    let history = getCommandHistory();
+    const newEntry = { question, command, time: new Date().toLocaleString() };
+    history = [newEntry, ...history.filter(item => item.command !== command)].slice(0, 5);
+    fs.writeFileSync(HISTORY_FILE, JSON.stringify(history, null, 2));
+}
+
+function getMacros() {
+    if (fs.existsSync(MACROS_FILE)) {
+        try {
+            return JSON.parse(fs.readFileSync(MACROS_FILE, 'utf8'));
+        } catch (e) {}
+    }
+    return {};
+}
+
+function saveMacro(name, commands, description = '') {
+    const macros = getMacros();
+    macros[name] = {
+        commands,
+        description,
+        createdAt: new Date().toISOString()
+    };
+    fs.writeFileSync(MACROS_FILE, JSON.stringify(macros, null, 2));
+    return true;
+}
+
+function deleteMacro(name) {
+    const macros = getMacros();
+    if (macros[name]) {
+        delete macros[name];
+        fs.writeFileSync(MACROS_FILE, JSON.stringify(macros, null, 2));
+        return true;
+    }
+    return false;
+}
+
 // Default apps (fallback if no config file exists)
 const DEFAULT_APPS = {
     shici: 'https://wealth.want.biz/shici/index.html',
@@ -103,21 +164,90 @@ function getConversationHistory() {
 /**
  * 通用 AI 调用函数 (OpenAI 兼容接口)
  */
+async function callAI_Stream(messages, model, onChunk) {
+    const config = getUserConfig();
+    const url = config.aiProxyUrl || 'https://aiproxy.want.biz/v1/chat/completions';
+
+    const response = await axios({
+        method: 'post',
+        url: url,
+        data: {
+            model: model || config.defaultModel || 'Assistant',
+            messages: messages,
+            stream: true
+        },
+        responseType: 'stream',
+        headers: {
+            'Content-Type': 'application/json',
+            'X-Client-ID': 'npm_yuangs',
+            'Origin': 'https://cli.want.biz',
+            'Referer': 'https://cli.want.biz/',
+            'account': config.accountType || 'free',
+            'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1',
+            'Accept': 'application/json'
+        }
+    });
+
+    return new Promise((resolve, reject) => {
+        let buffer = '';
+        response.data.on('data', chunk => {
+            buffer += chunk.toString();
+            let lines = buffer.split('\n');
+            // 数组的最后一个元素可能是不完整的行，留到下一次处理
+            buffer = lines.pop(); 
+
+            for (const line of lines) {
+                const trimmedLine = line.trim();
+                if (trimmedLine.startsWith('data: ')) {
+                    const data = trimmedLine.slice(6);
+                    if (data === '[DONE]') {
+                        resolve();
+                        return;
+                    }
+                    try {
+                        const parsed = JSON.parse(data);
+                        const content = parsed.choices[0]?.delta?.content || '';
+                        if (content) onChunk(content);
+                    } catch (e) {
+                        // 如果这一行真的有问题，忽略它
+                    }
+                }
+            }
+        });
+        response.data.on('error', reject);
+        response.data.on('end', () => {
+             // 处理缓冲区中剩余的内容（如果有）
+            if (buffer.trim().startsWith('data: ')) {
+                 try {
+                    const data = buffer.trim().slice(6);
+                    if (data !== '[DONE]') {
+                        const parsed = JSON.parse(data);
+                        const content = parsed.choices[0]?.delta?.content || '';
+                        if (content) onChunk(content);
+                    }
+                } catch (e) {}
+            }
+            resolve();
+        });
+    });
+}
+
 async function callAI_OpenAI(messages, model) {
-    const url = 'https://aiproxy.want.biz/v1/chat/completions';
+    const config = getUserConfig();
+    const url = config.aiProxyUrl || 'https://aiproxy.want.biz/v1/chat/completions';
 
     const headers = {
         'Content-Type': 'application/json',
-        'X-Client-ID': 'npm_yuangs', // 客户端 标识
-        'Origin': 'https://cli.want.biz', // 配合后端白名单
+        'X-Client-ID': 'npm_yuangs',
+        'Origin': 'https://cli.want.biz',
         'Referer': 'https://cli.want.biz/',
-        "account": "free",
+        'account': config.accountType || 'free',
         'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1',
         'Accept': 'application/json'
     };
 
     const data = {
-        model: model || "gemini-flash-lite-latest",
+        model: model || config.defaultModel || 'Assistant',
         messages: messages,
         stream: false
     };
@@ -162,8 +292,7 @@ async function getAIAnswer(question, model, includeHistory = true) {
 }
 
 async function generateCommand(instruction, model) {
-    // 构造 System Prompt (通过 system role 或者直接在 user message 中强调)
-    // Gemini 有时对 system role 支持不同，但在 OpenAI 兼容接口下通常支持 system
+    const config = getUserConfig();
     const messages = [
         {
             role: 'system',
@@ -177,20 +306,17 @@ async function generateCommand(instruction, model) {
     ];
 
     try {
-        const response = await callAI_OpenAI(messages, model);
+        const response = await callAI_OpenAI(messages, model || config.defaultModel);
         const aiContent = response.data?.choices?.[0]?.message?.content;
 
         if (aiContent) {
-            // Clean up the output just in case the AI adds markdown or whitespace
             let command = aiContent.trim();
-            // Remove wrapping backticks if present
             if (command.startsWith('`') && command.endsWith('`')) {
                 command = command.slice(1, -1);
             }
             if (command.startsWith('```') && command.endsWith('```')) {
                 command = command.split('\n').filter(line => !line.startsWith('```')).join('\n').trim();
             }
-            // If it starts with a shell prefix like "$ " or "> ", remove it
             if (command.startsWith('$ ')) command = command.slice(2);
             if (command.startsWith('> ')) command = command.slice(2);
 
@@ -198,15 +324,12 @@ async function generateCommand(instruction, model) {
         }
         return null;
     } catch (error) {
-        // 命令生成失败不打印过多错误，返回 null 即可
-        // console.error('AI 生成命令失败:', error.message); 
         return null;
     }
 }
 
 module.exports = {
     urls: APPS,
-    // Dynamic function to open any app by key
     openApp: (appKey) => {
         const url = APPS[appKey];
         if (url) {
@@ -216,7 +339,6 @@ module.exports = {
         console.error(`App '${appKey}' not found`);
         return false;
     },
-    // Specific functions for default apps (for backward compatibility)
     openShici: () => openUrl(APPS.shici || DEFAULT_APPS.shici),
     openDict: () => openUrl(APPS.dict || DEFAULT_APPS.dict),
     openPong: () => openUrl(APPS.pong || DEFAULT_APPS.pong),
@@ -228,5 +350,12 @@ module.exports = {
     addToConversationHistory,
     clearConversationHistory,
     getConversationHistory,
-    generateCommand
+    generateCommand,
+    getUserConfig,
+    getCommandHistory,
+    saveSuccessfulCommand,
+    callAI_Stream,
+    getMacros,
+    saveMacro,
+    deleteMacro
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yuangs",
-  "version": "1.3.34",
+  "version": "1.3.37",
   "description": "苑广山的个人应用集合 CLI（彩色版）",
   "main": "index.js",
   "bin": {
@@ -28,7 +28,10 @@
   "dependencies": {
     "axios": "^1.13.2",
     "chalk": "^4.1.2",
-    "js-yaml": "^4.1.0"
+    "js-yaml": "^4.1.0",
+    "marked": "^15.0.12",
+    "marked-terminal": "^7.3.0",
+    "ora": "^9.0.0"
   },
   "devDependencies": {
     "jest": "^29.7.0"

package/test/macros.test.js

@@ -0,0 +1,91 @@
+const fs = require('fs');
+const yuangs = require('../index.js');
+const path = require('path');
+const os = require('os');
+
+jest.mock('fs');
+
+describe('Module: Macros', () => {
+    const mockMacrosFile = path.join(os.homedir(), '.yuangs_macros.json');
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Setup default mock implementation
+        fs.existsSync.mockReturnValue(false);
+        fs.readFileSync.mockReturnValue('{}');
+        fs.writeFileSync.mockReturnValue(undefined);
+        // We need to unmock path and os if they were mocked, but we only mocked fs
+    });
+
+    test('should get empty macros when file does not exist', () => {
+        fs.existsSync.mockReturnValue(false);
+        const macros = yuangs.getMacros();
+        expect(macros).toEqual({});
+        expect(fs.existsSync).toHaveBeenCalledWith(mockMacrosFile);
+    });
+
+    test('should save a new macro', () => {
+        fs.existsSync.mockReturnValue(false); // File doesn't exist yet
+        
+        const result = yuangs.saveMacro('test', 'echo hello', 'description');
+        
+        expect(result).toBe(true);
+        expect(fs.writeFileSync).toHaveBeenCalled();
+        
+        const [filePath, content] = fs.writeFileSync.mock.calls[0];
+        expect(filePath).toBe(mockMacrosFile);
+        
+        const data = JSON.parse(content);
+        expect(data).toHaveProperty('test');
+        expect(data.test.commands).toBe('echo hello');
+        expect(data.test.description).toBe('description');
+        expect(data.test).toHaveProperty('createdAt');
+    });
+
+    test('should retrieve existing macros', () => {
+        const mockData = {
+            "demo": {
+                "commands": "ls -la",
+                "description": "list files"
+            }
+        };
+        fs.existsSync.mockReturnValue(true);
+        fs.readFileSync.mockReturnValue(JSON.stringify(mockData));
+
+        const macros = yuangs.getMacros();
+        expect(macros).toEqual(mockData);
+    });
+
+    test('should delete a macro', () => {
+        const mockData = {
+            "todelete": { "commands": "rm -rf /" },
+            "keep": { "commands": "echo safe" }
+        };
+        fs.existsSync.mockReturnValue(true);
+        fs.readFileSync.mockReturnValue(JSON.stringify(mockData));
+
+        const result = yuangs.deleteMacro('todelete');
+        
+        expect(result).toBe(true);
+        expect(fs.writeFileSync).toHaveBeenCalled();
+        
+        const [filePath, content] = fs.writeFileSync.mock.calls[0];
+        const savedData = JSON.parse(content);
+        expect(savedData).not.toHaveProperty('todelete');
+        expect(savedData).toHaveProperty('keep');
+    });
+
+    test('should return false when deleting non-existent macro', () => {
+        fs.existsSync.mockReturnValue(false); // Or true with empty object
+        
+        const result = yuangs.deleteMacro('nonexistent');
+        expect(result).toBe(false);
+        // Should not write to disk if nothing changed (optional optimization, but current implementation reads first)
+        // Actually current implementation:
+        // const macros = getMacros();
+        // if (macros[name]) { ... }
+        // getMacros returns {} if file not exists. macros['nonexistent'] is undefined.
+        // So it returns false and does NOT call writeFileSync.
+        expect(fs.writeFileSync).not.toHaveBeenCalled();
+    });
+});

package/todo.md

@@ -0,0 +1,273 @@
+功能1:历史记录功能
+没问题！我已经为你梳理好了完整的代码整合方案。通过这次整合，你的 yuangs 工具将拥有完整的配置管理、带语义的历史记录以及智能预填执行功能。
+1. index.js 完整核心逻辑
+请将以下函数添加到 index.js 中并确保在 module.exports 中导出：
+const os = require(’os‘);
+const HISTORY_FILE = path.join(os.homedir(), ’.yuangs_cmd_history.json‘);
+const CONFIG_FILE = path.join(os.homedir(), ’.yuangs.json‘);
+
+// — 配置管理 —
+function getUserConfig() {
+    if (fs.existsSync(CONFIG_FILE)) {
+        try {
+            return JSON.parse(fs.readFileSync(CONFIG_FILE, ’utf8‘));
+        } catch (e) {}
+    }
+    return {};
+}
+
+// — 历史记录管理 (带问题描述) —
+function getCommandHistory() {
+    if (fs.existsSync(HISTORY_FILE)) {
+        try {
+            return JSON.parse(fs.readFileSync(HISTORY_FILE, ’utf8‘));
+        } catch (e) {}
+    }
+    return [];
+}
+
+function saveSuccessfulCommand(question, command) {
+    if (!command) return;
+    let history = getCommandHistory();
+    const newEntry = { question, command, time: new Date().toLocaleString() };
+    // 去重并保留最近 5 条
+    history = [newEntry, ...history.filter(item => item.command !== command)].slice(0, 5);
+    fs.writeFileSync(HISTORY_FILE, JSON.stringify(history, null, 2));
+}
+
+// 修改原有的 callAI_OpenAI 适配配置
+async function callAI_OpenAI(messages, model) {
+    const config = getUserConfig();
+    const url = config.aiProxyUrl || ’https://aiproxy.want.biz/v1/chat/completions‘;
+    
+    const headers = {
+        ’Content-Type‘: ’application/json‘,
+        ’X-Client-ID‘: ’npm_yuangs‘,
+        ’account‘: config.accountType || ’free‘,
+        ’User-Agent‘: ’Mozilla/5.0...‘,
+        ’Accept‘: ’application/json‘
+    };
+
+    const data = {
+        model: model || config.defaultModel || ”gemini-flash-lite-latest“,
+        messages: messages,
+        stream: false
+    };
+
+    return await axios.post(url, data, { headers });
+}
+
+2. cli.js 交互层升级
+在 cli.js 的 switch 语句中添加 config 分支，并重构命令执行逻辑：
+// 新增执行函数
+function runFinalCommand(question, finalCommand) {
+    const { spawn } = require(’child_process‘);
+    console.log(chalk.gray(’正在执行...‘));
+    const child = spawn(finalCommand, [], { shell: true, stdio: ’inherit‘ });
+
+    child.on(’close‘, (code) => {
+        if (code === 0) {
+            yuangs.saveSuccessfulCommand(question, finalCommand);
+            console.log(chalk.green(’\n✓ 执行成功并已存入历史库‘));
+        }
+        process.exit(code);
+    });
+}
+
+// switch 分支
+switch (command) {
+    case ’config‘:
+        const [,, key, value] = process.argv;
+        if (!key || !value) {
+            console.log(chalk.cyan(’\n⚙️  配置帮助: yuangs config <key> <value>‘));
+            console.log(chalk.gray(’当前配置:‘), yuangs.getUserConfig());
+            break;
+        }
+        const config = yuangs.getUserConfig();
+        config[key] = value;
+        fs.writeFileSync(path.join(require(’os‘).homedir(), ’.yuangs.json‘), JSON.stringify(config, null, 2));
+        console.log(chalk.green(`✓ 已更新 ${key}`));
+        break;
+
+    // 在 handleAICommand 中加入 -h 处理逻辑 (如前所述)
+}
+
+3. 操作流程示意图
+现在的成果：
+ * 个性化：通过 yuangs config 适配不同的网络环境和模型需求。
+ * 知识库化：历史记录不仅存命令，还存“意图”，成为你个人的 Linux 命令词典。
+ * 极速复用：再次使用时，从意图出发，一秒加载，回车即跑。
+这套逻辑已经非常接近成熟的商业 CLI（如 Vercel 或 GitHub CLI）的交互体验了。你已经从基础的功能实现，跨越到了用户体验设计的层面。
+恭喜你完成了一个非常硬核的工具升级！ 接下来是准备把它发布到内部 npm 仓库，还是继续增加更炫酷的功能（比如给 AI 对话增加流式输出效果）？
+既然基础架构已经打好，我们可以跳出“简单的 AI 助手”这个范畴，把 yuangs 打造一个真正的智能终端工作台。
+作为一名命令行高手，你可以往以下四个维度去“脑洞大开”：
+1. 智能“管道”模式 (The Magic Pipe)
+现在的 AI 需要你手动输入问题，未来它可以直接处理前一个命令的输出。
+ * 功能描述：实现类似 ls -l | yuangs ai "帮我总结这些文件" 的功能。
+ * 实现思路：在 cli.js 中检测 process.stdin.isTTY。如果不是 TTY，说明有内容从管道传进来。
+ * 使用场景：
+   * cat error.log | yuangs ai "解释这个报错并给出修复建议"
+   * curl https://example.com | yuangs ai "提取所有的链接并转成 JSON"
+2. 交互式“变量注入” (Variable Injection)
+AI 生成的命令往往带有占位符（比如 <filename>），手动修改很麻烦。
+ * 功能描述：AI 生成命令后，工具自动识别其中的占位符，并引导用户逐个填空。
+ * 实现思路：AI 输出 tar -cvzf <压缩包名>.tar.gz <文件夹>，CLI 自动识别 <...> 语法，弹出输入框让用户填入具体值。
+ * 体验升级：甚至可以结合 fzf 类似的逻辑，让用户在填空时直接选择当前目录的文件。
+3. 终端“快捷指令” (AI Macros)
+有些复杂的流程（比如：切换 Git 分支 -> 拉取代码 -> 编译工程 -> 发送飞书通知）可以通过 AI 编排成一个专属命令。
+ * 功能描述：yuangs save "deploy-project"。
+ * 实现思路：将一连串命令封装成一个 Alias（别名）。
+ * 脑洞点：你可以给这个指令起名叫 go-home，AI 自动帮你执行“提交代码、关掉开发服务器、同步云端”等一系列收尾动作。
+4. 视觉增强与“流式”交互 (Visual & Stream)
+现在的命令行输出太死板，我们可以让它更有“生命力”。
+ * 功能描述：
+   * 流式输出：像 ChatGPT 网页版一样，字是一个一个蹦出来的（使用 stream: true 接口）。
+   * Markdown 渲染：在终端里渲染真正的 Markdown 格式（表格、代码块高亮），而不仅仅是纯文本。
+ * 实现工具：利用 marked-terminal 库来渲染，利用 ora 库做更酷炫的加载动画。
+推荐的升级路线图
+高手必做：增加“多模态”潜质
+既然你现在的后端支持 Gemini 模型，你可以尝试增加 “图片转代码” 的功能：
+ * 玩法：yuangs ai --image ./ui-design.png "帮我写出这个界面的 CSS"。
+ * 实现：利用 fs.readFileSync 将图片转为 Base64 发给 AI。
+这些想法中，你觉得哪个最能戳中你的痛点？我们可以挑一个最酷的，我现在就帮你写核心逻辑。
+既然基础架构已经打好，我们可以跳出“简单的 AI 助手”这个范畴，把 yuangs 打造一个真正的智能终端工作台。
+作为一名命令行高手，你可以往以下四个维度去“脑洞大开”：
+1. 智能“管道”模式 (The Magic Pipe)
+现在的 AI 需要你手动输入问题，未来它可以直接处理前一个命令的输出。
+ * 功能描述：实现类似 ls -l | yuangs ai ”帮我总结这些文件“ 的功能。
+ * 实现思路：在 cli.js 中检测 process.stdin.isTTY。如果不是 TTY，说明有内容从管道传进来。
+ * 使用场景：
+   * cat error.log | yuangs ai ”解释这个报错并给出修复建议“
+   * curl https://example.com | yuangs ai ”提取所有的链接并转成 JSON“
+2. 交互式“变量注入” (Variable Injection)
+AI 生成的命令往往带有占位符（比如 <filename>），手动修改很麻烦。
+ * 功能描述：AI 生成命令后，工具自动识别其中的占位符，并引导用户逐个填空。
+ * 实现思路：AI 输出 tar -cvzf <压缩包名>.tar.gz <文件夹>，CLI 自动识别 <...> 语法，弹出输入框让用户填入具体值。
+ * 体验升级：甚至可以结合 fzf 类似的逻辑，让用户在填空时直接选择当前目录的文件。
+3. 终端“快捷指令” (AI Macros)
+有些复杂的流程（比如：切换 Git 分支 -> 拉取代码 -> 编译工程 -> 发送飞书通知）可以通过 AI 编排成一个专属命令。
+ * 功能描述：yuangs save ”deploy-project“。
+ * 实现思路：将一连串命令封装成一个 Alias（别名）。
+ * 脑洞点：你可以给这个指令起名叫 go-home，AI 自动帮你执行“提交代码、关掉开发服务器、同步云端”等一系列收尾动作。
+4. 视觉增强与“流式”交互 (Visual & Stream)
+现在的命令行输出太死板，我们可以让它更有“生命力”。
+ * 功能描述：
+   * 流式输出：像 ChatGPT 网页版一样，字是一个一个蹦出来的（使用 stream: true 接口）。
+   * Markdown 渲染：在终端里渲染真正的 Markdown 格式（表格、代码块高亮），而不仅仅是纯文本。
+ * 实现工具：利用 marked-terminal 库来渲染，利用 ora 库做更酷炫的加载动画。
+推荐的升级路线图
+高手必做：增加“多模态”潜质
+既然你现在的后端支持 Gemini 模型，你可以尝试增加 “图片转代码” 的功能：
+ * 玩法：yuangs ai —image ./ui-design.png ”帮我写出这个界面的 CSS“。
+ * 实现：利用 fs.readFileSync 将图片转为 Base64 发给 AI。
+这些想法中，你觉得哪个最能戳中你的痛点？我们可以挑一个最酷的，我现在就帮你写核心逻辑。
+实现流式输出和 Markdown 渲染是提升 CLI 工具“质感”的关键。我们需要引入三个小巧但功能强大的库：
+ * ora: 实现酷炫的终端加载动画。
+ * marked & marked-terminal: 将 AI 返回的 Markdown 文本实时渲染为带颜色和样式的终端内容。
+1. 安装依赖
+首先，你需要在项目中安装这几个库：
+npm install ora marked marked-terminal
+
+2. 修改 index.js：支持流式 API 调用
+我们需要将 callAI_OpenAI 改写为支持 stream 模式。核心是处理 Node.js 的 IncomingMessage 流。
+// index.js 增加或修改如下逻辑
+async function callAI_Stream(messages, model, onChunk) {
+    const config = getUserConfig(); // 使用我们之前写的配置读取
+    const url = config.aiProxyUrl || 'https://aiproxy.want.biz/v1/chat/completions';
+
+    const response = await axios({
+        method: 'post',
+        url: url,
+        data: {
+            model: model || config.defaultModel || "gemini-flash-lite-latest",
+            messages: messages,
+            stream: true // 开启流式
+        },
+        responseType: 'stream',
+        headers: {
+            'Content-Type': 'application/json',
+            'X-Client-ID': 'npm_yuangs',
+            'account': config.accountType || 'free'
+        }
+    });
+
+    return new Promise((resolve, reject) => {
+        response.data.on('data', chunk => {
+            const lines = chunk.toString().split('\n');
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    const data = line.slice(6);
+                    if (data === '[DONE]') {
+                        resolve();
+                        return;
+                    }
+                    try {
+                        const parsed = JSON.parse(data);
+                        const content = parsed.choices[0].delta.content || '';
+                        if (content) onChunk(content); // 每出一个字，调用一次回调
+                    } catch (e) {
+                        // 忽略解析错误
+                    }
+                }
+            }
+        });
+        response.data.on('error', reject);
+    });
+}
+
+3. 修改 cli.js：视觉增强逻辑
+我们需要在 cli.js 中配置渲染器，并美化 handleAICommand。
+const ora = require('ora');
+const { marked } = require('marked');
+const TerminalRenderer = require('marked-terminal');
+
+// 配置 Markdown 渲染器
+marked.setOptions({
+    renderer: new TerminalRenderer({
+        code: chalk.yellow,
+        heading: chalk.magenta.bold,
+        firstHeading: chalk.magenta.underline.bold,
+        listitem: chalk.cyan,
+        table: chalk.white,
+        strong: chalk.bold.red,
+        em: chalk.italic
+    })
+});
+
+async function handleAICommand() {
+    // ... 前置参数解析逻辑 ...
+
+    const spinner = ora(chalk.cyan('AI 正在思考...')).start();
+    let fullResponse = '';
+
+    try {
+        await yuangs.callAI_Stream(messages, model, (chunk) => {
+            if (spinner.isSpinning) {
+                spinner.stop(); // 收到第一个字时，停止动画
+            }
+            fullResponse += chunk;
+            
+            // 实时打印字符，不换行
+            process.stdout.write(chunk); 
+        });
+
+        // 所有的流传输完成后，我们清除之前的原始输出，渲染漂亮的 Markdown
+        console.log('\n' + chalk.gray('─'.repeat(process.stdout.columns / 2)));
+        console.clear(); // 或者向上滚动重新覆盖
+        console.log(marked(fullResponse));
+        
+    } catch (error) {
+        spinner.fail(chalk.red('AI 响应出错'));
+        console.error(error.message);
+    }
+}
+
+4. 优化：命令生成的特殊处理
+注意：生成 Linux 命令（即 yuangs ai -e）时不建议使用流式 Markdown 渲染。
+ * 原因：生成命令需要绝对的纯文本，且通常很短。
+ * 建议：只在普通聊天模式下使用流式渲染；在 -e 命令生成模式下，保持原来的加载动画 + 结果预填。
+为什么这个实现很“高手”？
+ * 响应速度感：用户在 500ms 内就能看到第一个字跳出来，感知速度提升了 3-5 倍。
+ * 沉浸式体验：marked-terminal 会自动根据终端宽度调整列表和代码块的间距。
+ * 色彩层级：比起纯白色的文本，带有语法高亮的输出能让用户一眼看到代码块在哪里。
+你现在就可以尝试把这段逻辑合并进你的代码中。合并完成后，你的 yuangs 就像是一个运行在终端里的“小 ChatGPT”了！

package/yuangs.config.json

@@ -0,0 +1,9 @@
+{
+  "shici": "https://wealth.want.biz/shici/index.html",
+  "dict": "https://wealth.want.biz/pages/dict.html",
+  "pong": "https://wealth.want.biz/pages/pong.html",
+  "mail": "https://mail.google.com",
+  "github": "https://github.com",
+  "calendar": "https://calendar.google.com",
+  "homepage": "https://i.want.biz"
+}