@lmcc-dev/mult-fetch-mcp-server 1.1.0 → 1.2.1

package/dist/tests/i18n-unused-keys.js

@@ -0,0 +1,425 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+// 检测未使用的国际化键 (Detect unused internationalization keys)
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { enTranslation } from '../src/lib/i18n/locales/en/index.js';
+import { zhTranslation } from '../src/lib/i18n/locales/zh/index.js';
+import * as allKeys from '../src/lib/i18n/keys/index.js';
+// 获取当前文件的目录路径 (Get the directory path of the current file)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// 默认测试配置 (Default test configuration)
+const defaultConfig = {
+    generateReport: true,
+    reportPath: path.join(__dirname, '../i18n-unused-keys-report.json'),
+    verbose: false,
+    srcDir: path.join(__dirname, '../src'),
+    excludeDirs: ['node_modules', 'dist', 'build', 'coverage'],
+    fileExtensions: ['.ts', '.tsx', '.js', '.jsx'],
+    preserveErrorKeys: true, // 默认保留错误相关的键 (Preserve error-related keys by default)
+    reportOnly: false, // 默认不只生成报告 (Don't only generate report by default)
+    strictMode: true // 默认使用严格模式 (Use strict mode by default)
+};
+// 解析命令行参数 (Parse command line arguments)
+function parseCommandLineArgs() {
+    const config = { ...defaultConfig };
+    const args = process.argv.slice(2);
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '--no-report':
+                config.generateReport = false;
+                break;
+            case '--report-path':
+                if (i + 1 < args.length) {
+                    config.reportPath = args[++i];
+                }
+                break;
+            case '--verbose':
+                config.verbose = true;
+                break;
+            case '--src-dir':
+                if (i + 1 < args.length) {
+                    config.srcDir = args[++i];
+                }
+                break;
+            case '--exclude-dirs':
+                if (i + 1 < args.length) {
+                    config.excludeDirs = args[++i].split(',');
+                }
+                break;
+            case '--file-extensions':
+                if (i + 1 < args.length) {
+                    config.fileExtensions = args[++i].split(',');
+                }
+                break;
+            case '--no-preserve-error-keys':
+                config.preserveErrorKeys = false;
+                break;
+            case '--report-only':
+                config.reportOnly = true;
+                break;
+            case '--no-strict-mode':
+                config.strictMode = false;
+                break;
+            case '--help':
+                printHelp();
+                process.exit(0);
+                break;
+        }
+    }
+    return config;
+}
+// 打印帮助信息 (Print help information)
+function printHelp() {
+    console.log(`
+未使用国际化键检测工具 (Unused Internationalization Keys Detection Tool)
+
+用法: node --loader ts-node/esm tests/i18n-unused-keys.ts [选项]
+
+选项:
+  --no-report                不生成报告文件 (Don't generate report file)
+  --report-path <path>       指定报告文件路径 (Specify report file path)
+  --verbose                  显示详细信息 (Show verbose information)
+  --src-dir <path>           指定源代码目录 (Specify source code directory)
+  --exclude-dirs <dirs>      指定排除的目录，用逗号分隔 (Specify excluded directories, separated by commas)
+  --file-extensions <exts>   指定文件扩展名，用逗号分隔 (Specify file extensions, separated by commas)
+  --no-preserve-error-keys   不保留错误相关的键 (Don't preserve error-related keys)
+  --report-only              只生成报告，不执行删除 (Only generate report, don't delete)
+  --no-strict-mode           不使用严格模式，可能会误报 (Don't use strict mode, may have false positives)
+  --help                     显示帮助信息 (Show help information)
+  `);
+}
+/**
+ * 递归获取对象中的所有键 (Recursively get all keys in an object)
+ * @param obj 要获取键的对象 (Object to get keys from)
+ * @param prefix 键前缀 (Key prefix)
+ * @returns 键数组 (Array of keys)
+ */
+function getAllKeysFromObject(obj, prefix = '') {
+    let keys = [];
+    for (const key in obj) {
+        if (typeof obj[key] === 'object' && obj[key] !== null) {
+            // 递归获取嵌套对象的键 (Recursively get keys of nested objects)
+            keys = [...keys, ...getAllKeysFromObject(obj[key], prefix ? `${prefix}.${key}` : key)];
+        }
+        else if (typeof obj[key] === 'string') {
+            // 直接使用键值作为完整的键路径 (Use key value as the complete key path)
+            keys.push(obj[key]);
+        }
+    }
+    return keys;
+}
+/**
+ * 从键模块中获取所有键 (Get all keys from key modules)
+ * @returns 键数组 (Array of keys)
+ */
+function getAllKeysFromModules() {
+    const allKeysSet = new Set();
+    // 遍历所有键模块 (Iterate through all key modules)
+    for (const moduleKey in allKeys) {
+        const keyModule = allKeys[moduleKey];
+        if (typeof keyModule === 'object' && keyModule !== null) {
+            // 获取模块中的所有键 (Get all keys in the module)
+            const keysInModule = getAllKeysFromObject(keyModule);
+            keysInModule.forEach(key => allKeysSet.add(key));
+        }
+    }
+    return Array.from(allKeysSet);
+}
+/**
+ * 获取翻译值 (Get translation value)
+ * @param key 键 (Key)
+ * @param translations 翻译资源 (Translation resources)
+ * @returns 翻译值 (Translation value)
+ */
+function getTranslationValue(key, translations) {
+    // 检查是否是命名空间格式的键 (Check if the key is in namespace format)
+    const parts = key.split('.');
+    if (parts.length > 1) {
+        const namespace = parts[0];
+        const subKey = parts.slice(1).join('.');
+        // 检查命名空间是否存在 (Check if the namespace exists)
+        if (translations[namespace] && translations[namespace][subKey] !== undefined) {
+            return translations[namespace][subKey];
+        }
+    }
+    // 直接在翻译资源中查找键 (Look up the key directly in translation resources)
+    for (const moduleName in translations) {
+        const module = translations[moduleName];
+        if (module && module[key] !== undefined) {
+            return module[key];
+        }
+    }
+    return undefined;
+}
+/**
+ * 获取项目中的所有源代码文件 (Get all source code files in the project)
+ * @param config 测试配置 (Test configuration)
+ * @returns 文件路径数组 (Array of file paths)
+ */
+async function getAllSourceFiles(config) {
+    const { srcDir, excludeDirs, fileExtensions } = config;
+    console.log(`查找源代码文件，目录: ${srcDir} (Finding source code files, directory: ${srcDir})`);
+    try {
+        // 使用更简单的方法查找文件 (Use a simpler method to find files)
+        const allFiles = [];
+        // 递归查找文件 (Recursively find files)
+        function findFilesRecursively(dir) {
+            const files = fs.readdirSync(dir);
+            for (const file of files) {
+                const filePath = path.join(dir, file);
+                const stat = fs.statSync(filePath);
+                // 检查是否是目录 (Check if it's a directory)
+                if (stat.isDirectory()) {
+                    // 检查是否应该排除该目录 (Check if the directory should be excluded)
+                    if (!excludeDirs.some(excludeDir => file === excludeDir)) {
+                        findFilesRecursively(filePath);
+                    }
+                }
+                else if (stat.isFile()) {
+                    // 检查文件扩展名 (Check file extension)
+                    const ext = path.extname(file);
+                    if (fileExtensions.includes(ext)) {
+                        allFiles.push(filePath);
+                    }
+                }
+            }
+        }
+        // 开始递归查找 (Start recursive search)
+        findFilesRecursively(srcDir);
+        // 也包括测试目录 (Also include test directory)
+        const testDir = path.join(__dirname, '..');
+        if (testDir !== srcDir) {
+            findFilesRecursively(testDir);
+        }
+        console.log(`找到 ${allFiles.length} 个源代码文件 (Found ${allFiles.length} source code files)`);
+        return allFiles;
+    }
+    catch (error) {
+        console.error(`获取源代码文件时出错 (Error getting source code files):`, error);
+        return [];
+    }
+}
+/**
+ * 检查文件中是否使用了指定的键 (Check if a key is used in a file)
+ * @param filePath 文件路径 (File path)
+ * @param key 键 (Key)
+ * @returns 是否使用了键 (Whether the key is used)
+ */
+function isKeyUsedInFile(filePath, key) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        // 检查直接使用键的情况 (Check direct key usage)
+        if (content.includes(`'${key}'`) || content.includes(`"${key}"`)) {
+            return true;
+        }
+        // 检查使用 t 函数的情况 (Check usage with t function)
+        if (content.includes(`t('${key}'`) || content.includes(`t("${key}"`)) {
+            return true;
+        }
+        // 检查使用 log 函数的情况 (Check usage with log function)
+        if (content.includes(`log('${key}'`) || content.includes(`log("${key}"`)) {
+            return true;
+        }
+        // 检查动态生成的键名 (Check dynamically generated key names)
+        const parts = key.split('.');
+        if (parts.length > 1) {
+            const namespace = parts[0];
+            const subKey = parts.slice(1).join('.');
+            // 检查使用模板字符串的情况 (Check usage with template strings)
+            if (content.includes(`\`${namespace}.`) ||
+                (content.includes(`\`\${`) && content.includes(`}.${subKey}\``))) {
+                return true;
+            }
+            // 检查使用字符串拼接的情况 (Check usage with string concatenation)
+            if (content.includes(`'${namespace}.' +`) || content.includes(`"${namespace}." +`) ||
+                content.includes(`+ '.${subKey}'`) || content.includes(`+ ".${subKey}"`)) {
+                return true;
+            }
+            // 检查使用变量拼接的情况 (Check usage with variable concatenation)
+            if (content.includes(`${namespace}.` + subKey) ||
+                content.includes(`${namespace}["${subKey}"]`) ||
+                content.includes(`${namespace}['${subKey}']`)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch (error) {
+        console.error(`读取文件 ${filePath} 时出错 (Error reading file ${filePath}):`, error);
+        return false;
+    }
+}
+/**
+ * 检查键是否在任何文件中使用 (Check if a key is used in any file)
+ * @param key 键 (Key)
+ * @param files 文件路径数组 (Array of file paths)
+ * @param config 测试配置 (Test configuration)
+ * @returns 是否使用了键 (Whether the key is used)
+ */
+function isKeyUsed(key, files, config) {
+    // 如果配置为保留错误相关的键，并且键以 errors. 开头，则认为它是使用的
+    if (config.preserveErrorKeys && key.startsWith('errors.')) {
+        if (config.verbose) {
+            console.log(`保留错误相关的键: ${key} (Preserving error-related key: ${key})`);
+        }
+        return true;
+    }
+    // 在严格模式下，保留所有可能动态生成的键
+    if (config.strictMode) {
+        // 保留所有可能通过动态方式使用的键
+        const parts = key.split('.');
+        if (parts.length > 1) {
+            const namespace = parts[0];
+            // 检查是否有文件包含这个命名空间的动态键生成
+            for (const file of files) {
+                const content = fs.readFileSync(file, 'utf-8');
+                // 检查各种动态键生成模式
+                if (content.includes(`${namespace}.`) &&
+                    (content.includes('variable') ||
+                        content.includes('dynamic') ||
+                        content.includes('concat') ||
+                        content.includes('join') ||
+                        content.includes('template'))) {
+                    if (config.verbose) {
+                        console.log(`可能动态使用的键: ${key} 在文件 ${file} 中 (Potentially dynamically used key: ${key} in file ${file})`);
+                    }
+                    return true;
+                }
+            }
+        }
+    }
+    // 检查每个文件中是否使用了键
+    for (const file of files) {
+        if (isKeyUsedInFile(file, key)) {
+            if (config.verbose) {
+                console.log(`键 ${key} 在文件 ${file} 中使用 (Key ${key} is used in file ${file})`);
+            }
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 生成报告 (Generate report)
+ * @param report 报告数据 (Report data)
+ * @param reportPath 报告文件路径 (Report file path)
+ */
+function generateReport(report, reportPath) {
+    try {
+        // 创建目录 (Create directory)
+        const dir = path.dirname(reportPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        // 写入报告文件 (Write report file)
+        fs.writeFileSync(reportPath, JSON.stringify(report, null, 2), 'utf-8');
+        console.log(`报告已生成: ${reportPath} (Report generated: ${reportPath})`);
+    }
+    catch (error) {
+        console.error(`生成报告时出错 (Error generating report):`, error);
+    }
+}
+/**
+ * 检查未使用的键 (Check unused keys)
+ * @param config 测试配置 (Test configuration)
+ */
+async function checkUnusedKeys(config) {
+    console.log('\n=== 检查未使用的国际化键 (Check unused internationalization keys) ===');
+    try {
+        // 获取所有键 (Get all keys)
+        const allKeys = getAllKeysFromModules();
+        console.log(`总计找到 ${allKeys.length} 个键 (Total keys found: ${allKeys.length})`);
+        // 获取所有源代码文件 (Get all source code files)
+        const files = await getAllSourceFiles(config);
+        console.log(`总计找到 ${files.length} 个源代码文件 (Total source code files found: ${files.length})`);
+        // 检查每个键是否被使用 (Check if each key is used)
+        const unusedKeys = [];
+        const usedKeys = [];
+        for (const key of allKeys) {
+            if (isKeyUsed(key, files, config)) {
+                usedKeys.push(key);
+            }
+            else {
+                unusedKeys.push(key);
+            }
+        }
+        // 输出结果 (Output results)
+        if (unusedKeys.length > 0) {
+            console.log(`\n❌ 发现 ${unusedKeys.length} 个未使用的键 (Found ${unusedKeys.length} unused keys)`);
+            console.log(`✅ 发现 ${usedKeys.length} 个使用的键 (Found ${usedKeys.length} used keys)`);
+            if (config.verbose) {
+                for (const key of unusedKeys) {
+                    const enValue = getTranslationValue(key, enTranslation);
+                    const zhValue = getTranslationValue(key, zhTranslation);
+                    console.log(`键 (Key): ${key}`);
+                    console.log(`英文值 (English value): ${enValue}`);
+                    console.log(`中文值 (Chinese value): ${zhValue}`);
+                    console.log('---');
+                }
+            }
+        }
+        else {
+            console.log('\n✅ 所有键都被使用 (All keys are used)');
+        }
+        // 生成报告 (Generate report)
+        if (config.generateReport) {
+            const report = {
+                timestamp: new Date().toISOString(),
+                totalKeys: allKeys.length,
+                totalUsedKeys: usedKeys.length,
+                totalFiles: files.length,
+                unusedKeys: unusedKeys.map(key => ({
+                    key,
+                    enValue: getTranslationValue(key, enTranslation),
+                    zhValue: getTranslationValue(key, zhTranslation)
+                })),
+                hasUnusedKeys: unusedKeys.length > 0
+            };
+            generateReport(report, config.reportPath);
+        }
+        return {
+            unusedKeys,
+            hasUnusedKeys: unusedKeys.length > 0
+        };
+    }
+    catch (error) {
+        console.error('\n❌ 检查未使用的键时出错 (Error checking unused keys):');
+        console.error(error);
+        return {
+            unusedKeys: [],
+            hasUnusedKeys: true
+        };
+    }
+}
+/**
+ * 主函数 (Main function)
+ */
+async function main() {
+    console.log('=== 检测未使用的国际化键 (Detecting unused internationalization keys) ===');
+    try {
+        // 解析命令行参数 (Parse command line arguments)
+        const config = parseCommandLineArgs();
+        // 检查是否只生成报告 (Check if only generating report)
+        if (config.reportOnly) {
+            console.log('只生成报告，不执行删除 (Only generating report, not deleting)');
+        }
+        // 检查未使用的键 (Check unused keys)
+        const result = await checkUnusedKeys(config);
+        // 设置退出码 (Set exit code)
+        process.exit(result.hasUnusedKeys ? 1 : 0);
+    }
+    catch (error) {
+        console.error('❌ 程序执行出错 (Error executing program):');
+        console.error(error);
+        process.exit(1);
+    }
+}
+// 执行主函数 (Execute main function)
+main();

package/dist/tests/i18n.test.js

@@ -5,6 +5,7 @@
  */
 import i18next, { t, changeLanguage, getCurrentLanguage } from '../src/lib/i18n/index.js';
 import { createLogger } from '../src/lib/i18n/logger.js';
+import { vi, describe, test, expect, beforeEach, afterEach } from 'vitest';
 describe('i18n模块测试 (i18n Module Tests)', () => {
     // 保存原始环境变量
     const originalEnv = process.env.MCP_LANG;
@@ -81,8 +82,8 @@ describe('i18n Logger模块测试 (i18n Logger Module Tests)', () => {
     const originalConsoleError = console.error;
     // 在每个测试前设置mock
     beforeEach(() => {
-        console.log = jest.fn();
-        console.error = jest.fn();
+        console.log = vi.fn();
+        console.error = vi.fn();
         process.env.DEBUG = 'false';
     });
     // 在每个测试后恢复原始方法
@@ -100,13 +101,11 @@ describe('i18n Logger模块测试 (i18n Logger Module Tests)', () => {
         expect(logger).toHaveProperty('warn');
         expect(logger).toHaveProperty('debug');
     });
-    test('info方法在DEBUG=true时输出日志 (info method outputs logs when DEBUG=true)', () => {
-        // 设置DEBUG环境变量为true
-        process.env.DEBUG = 'true';
+    test('info方法在forceLog=true时输出日志 (info method outputs logs when forceLog=true)', () => {
         // 创建日志记录器
         const logger = createLogger('TEST');
-        // 调用info方法
-        logger.info('test.info');
+        // 调用info方法，设置forceLog为true
+        logger.info('test.info', {}, true);
         // 验证console.error被调用（i18n logger使用console.error输出所有日志）
         expect(console.error).toHaveBeenCalled();
         // 验证调用参数包含前缀和消息

package/dist/tests/logger.test.js

@@ -4,15 +4,16 @@
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
 import { log, COMPONENTS } from '../src/lib/logger.js';
+import { vi, describe, test, expect, beforeEach, afterEach } from 'vitest';
 // 模拟i18n模块
-jest.mock('../src/lib/i18n/index.js', () => ({
+vi.mock('../src/lib/i18n/index.js', () => ({
     t: (key, options) => {
         // 简单地返回原始key，用于测试
         return options ? `${key} ${JSON.stringify(options)}` : key;
     }
 }));
 // 模拟i18n/logger模块
-jest.mock('../src/lib/i18n/logger.js', () => ({
+vi.mock('../src/lib/i18n/logger.js', () => ({
     createLogger: (prefix) => ({
         debug: (key, params, forceDebug) => {
             if (forceDebug === true) {
@@ -37,8 +38,8 @@ describe('Logger模块测试 (Logger Module Tests)', () => {
     // 在每个测试前设置mock
     beforeEach(() => {
         // Mock console.log和console.error
-        console.log = jest.fn();
-        console.error = jest.fn();
+        console.log = vi.fn();
+        console.error = vi.fn();
     });
     // 在每个测试后恢复原始函数
     afterEach(() => {
@@ -48,10 +49,10 @@ describe('Logger模块测试 (Logger Module Tests)', () => {
     test('正常日志输出 (Normal log output)', () => {
         // 调用log函数，debug设为true
         log('test.message', true, {}, COMPONENTS.SERVER);
-        // 验证console.log被调用
-        expect(console.log).toHaveBeenCalled();
+        // 验证console.error被调用
+        expect(console.error).toHaveBeenCalled();
         // 验证调用参数包含正确的组件和消息
-        const callArg = console.log.mock.calls[0][0];
+        const callArg = console.error.mock.calls[0][0];
         expect(callArg).toContain(COMPONENTS.SERVER);
         expect(callArg).toContain('test.message');
     });
@@ -69,10 +70,10 @@ describe('Logger模块测试 (Logger Module Tests)', () => {
         const extraData = { key: 'value', number: 123 };
         // 调用log函数，传入额外数据，debug设为true
         log('test.extra', true, extraData, COMPONENTS.NODE_FETCH);
-        // 验证console.log被调用
-        expect(console.log).toHaveBeenCalled();
+        // 验证console.error被调用
+        expect(console.error).toHaveBeenCalled();
         // 验证调用参数包含正确的组件、消息和额外数据
-        const callArg = console.log.mock.calls[0][0];
+        const callArg = console.error.mock.calls[0][0];
         expect(callArg).toContain(COMPONENTS.NODE_FETCH);
         expect(callArg).toContain('test.extra');
         expect(callArg).toContain(JSON.stringify(extraData));
@@ -82,10 +83,10 @@ describe('Logger模块测试 (Logger Module Tests)', () => {
         Object.values(COMPONENTS).forEach(component => {
             // 调用log函数，debug设为true
             log('test.component', true, {}, component);
-            // 验证console.log被调用
-            expect(console.log).toHaveBeenCalled();
+            // 验证console.error被调用
+            expect(console.error).toHaveBeenCalled();
             // 验证调用参数包含正确的组件
-            const callArg = console.log.mock.calls.pop()[0];
+            const callArg = console.error.mock.calls.pop()[0];
             expect(callArg).toContain(component);
         });
     });

package/dist/tests/mcp-server.test.js

@@ -4,18 +4,18 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
-import { jest } from '@jest/globals';
+import { vi, describe, test, expect, beforeEach, afterAll } from 'vitest';
 // 模拟依赖模块
-const mockStartServer = jest.fn();
-jest.mock('../src/lib/server/index.js', () => ({
+const mockStartServer = vi.fn();
+vi.mock('../src/lib/server/index.js', () => ({
     startServer: mockStartServer
 }));
 // 模拟 console.error
 const originalConsoleError = console.error;
-console.error = jest.fn();
+console.error = vi.fn();
 // 模拟 process.exit
 const originalProcessExit = process.exit;
-const mockExit = jest.fn();
+const mockExit = vi.fn();
 Object.defineProperty(process, 'exit', { value: mockExit });
 // 创建一个模拟的 main 函数
 const main = async () => {
@@ -39,7 +39,7 @@ const main = async () => {
 describe('mcp-server.ts 测试', () => {
     // 在每个测试前重置所有模拟
     beforeEach(() => {
-        jest.clearAllMocks();
+        vi.clearAllMocks();
     });
     // 在所有测试后恢复原始值
     afterAll(() => {
@@ -84,7 +84,7 @@ describe('mcp-server.ts 测试', () => {
             const timeoutError = new Error('Server startup timed out after 30000ms');
             // 模拟 setTimeout 立即执行
             const originalSetTimeout = global.setTimeout;
-            global.setTimeout = jest.fn().mockImplementation((callback) => {
+            global.setTimeout = vi.fn().mockImplementation((callback) => {
                 // 不立即执行回调，而是手动触发错误
                 return 123;
             });