@agentscope-ai/i18n 0.1.2

package/lib/core/translator.js

@@ -0,0 +1,924 @@
+const fs = require('fs-extra');
+const path = require('path');
+const find = require('find');
+const { parse } = require('@babel/parser');
+const traverse = require('@babel/traverse').default;
+const generate = require('@babel/generator').default;
+const { scanFiles } = require('../utils/file-utils');
+const {
+  processFiles,
+  translateAndUpdateFiles,
+  singleTranslateAndUpdateFiles,
+} = require('./file-processor');
+const { extractI18nKey } = require('../utils/ast-utils');
+const { askQuestion } = require('../utils/cli-utils');
+const { generateMedusaExcel } = require('../utils/excel-utils');
+// inquirer需要动态导入，因为它是ES模块
+const t = require('@babel/types');
+
+// 解析AST
+const parseAST = (code) => {
+  return parse(code, {
+    sourceType: 'module',
+    plugins: ['jsx', 'typescript'],
+  });
+};
+
+// 生成代码
+const generateCode = (ast, originalCode) => {
+  return generate(
+    ast,
+    {
+      jsescOption: {
+        minimal: true,
+        quotes: 'single',
+      },
+      retainLines: false,
+      compact: 'auto',
+    },
+    originalCode,
+  ).code;
+};
+
+// 初始化翻译
+const init = async function (sourcePath, params) {
+  try {
+    const {
+      fileType = '.tsx,.js,.ts,.jsx',
+      localesFilePath,
+      keyPrefix,
+      doNotTranslateFiles,
+      functionImportPath,
+      i18nFilePath,
+      dashScope,
+      medusa,
+    } = params;
+
+    if (!keyPrefix) {
+      throw new Error('keyPrefix is required in params');
+    }
+
+    const files = scanFiles(sourcePath, fileType, doNotTranslateFiles);
+    const { i18n, fileCodeMap, needImportFiles } = await processFiles(files, params);
+    await translateAndUpdateFiles(
+      i18n,
+      sourcePath,
+      localesFilePath,
+      fileType,
+      fileCodeMap,
+      needImportFiles,
+      functionImportPath,
+      false,
+      dashScope,
+      medusa,
+    );
+
+    // 如果配置了i18nFilePath，复制i18n.ts文件
+    if (i18nFilePath) {
+      const sourceI18nPath = path.join(__dirname, '../i18n.ts');
+      const targetI18nPath = path.join(i18nFilePath, 'index.ts');
+
+      // 确保目标目录存在
+      fs.ensureDirSync(i18nFilePath);
+
+      // 复制文件
+      fs.copyFileSync(sourceI18nPath, targetI18nPath);
+      console.log(`    i18n.ts文件已复制到 ${targetI18nPath}`);
+    }
+
+    console.log(`    init: ${sourcePath} 目录下文件中文文案提取、替换和翻译成功！`);
+  } catch (error) {
+    console.error('    [错误] 初始化失败:', error);
+    throw error;
+  }
+};
+
+// 使用MT方式的初始化翻译
+const initMT = async function (sourcePath, params) {
+  try {
+    const {
+      fileType = '.tsx,.js,.ts,.jsx',
+      localesFilePath,
+      keyPrefix,
+      doNotTranslateFiles,
+      functionImportPath,
+      i18nFilePath,
+      dashScope,
+      medusa,
+    } = params;
+
+    if (!keyPrefix) {
+      throw new Error('keyPrefix is required in params');
+    }
+
+    if (!dashScope || !dashScope.apiKey) {
+      throw new Error('dashScope.apiKey is required for MT translation');
+    }
+
+    console.log('    [信息] 使用MT方式进行单条翻译...');
+
+    const files = scanFiles(sourcePath, fileType, doNotTranslateFiles);
+    const { i18n, fileCodeMap, needImportFiles } = await processFiles(files, params);
+    await singleTranslateAndUpdateFiles(
+      i18n,
+      sourcePath,
+      localesFilePath,
+      fileType,
+      fileCodeMap,
+      needImportFiles,
+      functionImportPath,
+      false,
+      dashScope,
+      medusa,
+    );
+
+    // 如果配置了i18nFilePath，复制i18n.ts文件
+    if (i18nFilePath) {
+      const sourceI18nPath = path.join(__dirname, '../i18n.ts');
+      const targetI18nPath = path.join(i18nFilePath, 'index.ts');
+
+      // 确保目标目录存在
+      fs.ensureDirSync(i18nFilePath);
+
+      // 复制文件
+      fs.copyFileSync(sourceI18nPath, targetI18nPath);
+      console.log(`    i18n.ts文件已复制到 ${targetI18nPath}`);
+    }
+
+    console.log(`    initMT: ${sourcePath} 目录下文件中文文案提取、替换和MT翻译成功！`);
+  } catch (error) {
+    console.error('    [错误] MT初始化失败:', error);
+    throw error;
+  }
+};
+
+// 补丁更新
+const patch = async function (sourcePath, params) {
+  const {
+    fileType = '.tsx,.js,.ts,.jsx',
+    localesFilePath,
+    keyPrefix,
+    doNotTranslateFiles,
+    functionImportPath,
+    i18nFilePath,
+    dashScope,
+    medusa,
+  } = params;
+
+  if (!keyPrefix) {
+    throw new Error('keyPrefix is required in params');
+  }
+
+  const files = scanFiles(sourcePath, fileType, doNotTranslateFiles);
+  console.log(`    # 检查${files.length}个${fileType}文件`);
+
+  const { i18n, fileCodeMap, needImportFiles } = await processFiles(files, params);
+  const newKeysCount = await translateAndUpdateFiles(
+    i18n,
+    sourcePath,
+    localesFilePath,
+    fileType,
+    fileCodeMap,
+    needImportFiles,
+    functionImportPath,
+    true,
+    dashScope,
+    medusa,
+  );
+
+  // 如果配置了i18nFilePath，检查并复制i18n.ts文件
+  if (i18nFilePath) {
+    const sourceI18nPath = path.join(__dirname, '../i18n.ts');
+    const targetI18nPath = path.join(i18nFilePath, 'index.ts');
+
+    // 检查目标文件是否已存在
+    if (!fs.existsSync(targetI18nPath)) {
+      // 确保目标目录存在
+      fs.ensureDirSync(i18nFilePath);
+
+      // 复制文件
+      fs.copyFileSync(sourceI18nPath, targetI18nPath);
+      console.log(`    [完成] i18n.ts文件已复制到 ${targetI18nPath}`);
+    } else {
+      console.log(`    [提示] i18n.ts文件已存在于 ${targetI18nPath}，跳过复制`);
+    }
+  }
+
+  console.log(`    新增文案补充翻译完成！新增${newKeysCount}条翻译文案`);
+};
+
+// 使用MT方式的补丁更新
+const patchMT = async function (sourcePath, params) {
+  const {
+    fileType = '.tsx,.js,.ts,.jsx',
+    localesFilePath,
+    keyPrefix,
+    doNotTranslateFiles,
+    functionImportPath,
+    i18nFilePath,
+    dashScope,
+    medusa,
+  } = params;
+
+  if (!keyPrefix) {
+    throw new Error('keyPrefix is required in params');
+  }
+
+  if (!dashScope || !dashScope.apiKey) {
+    throw new Error('dashScope.apiKey is required for MT translation');
+  }
+
+  console.log('    [信息] 使用MT方式进行单条翻译补丁更新...');
+
+  const files = scanFiles(sourcePath, fileType, doNotTranslateFiles);
+  console.log(`    # 检查${files.length}个${fileType}文件`);
+
+  const { i18n, fileCodeMap, needImportFiles } = await processFiles(files, params);
+  const newKeysCount = await singleTranslateAndUpdateFiles(
+    i18n,
+    sourcePath,
+    localesFilePath,
+    fileType,
+    fileCodeMap,
+    needImportFiles,
+    functionImportPath,
+    true,
+    dashScope,
+    medusa,
+  );
+
+  // 如果配置了i18nFilePath，检查并复制i18n.ts文件
+  if (i18nFilePath) {
+    const sourceI18nPath = path.join(__dirname, '../i18n.ts');
+    const targetI18nPath = path.join(i18nFilePath, 'index.ts');
+
+    // 检查目标文件是否已存在
+    if (!fs.existsSync(targetI18nPath)) {
+      // 确保目标目录存在
+      fs.ensureDirSync(i18nFilePath);
+
+      // 复制文件
+      fs.copyFileSync(sourceI18nPath, targetI18nPath);
+      console.log(`    [完成] i18n.ts文件已复制到 ${targetI18nPath}`);
+    } else {
+      console.log(`    [提示] i18n.ts文件已存在于 ${targetI18nPath}，跳过复制`);
+    }
+  }
+
+  console.log(`    新增文案MT翻译补充完成！新增${newKeysCount}条翻译文案`);
+};
+
+// 扫描文件并收集使用的key和dm值
+const scanFilesAndCollectKeys = (files) => {
+  const usedKeys = new Set();
+  const usedKeysData = {}; // 存储key对应的dm值（中文默认值）
+
+  files.forEach((file) => {
+    try {
+      const code = fs.readFileSync(file, 'utf8');
+      const ast = parseAST(code);
+
+      traverse(ast, {
+        CallExpression(path) {
+          const result = extractI18nKey(path.node);
+          if (result && result.id) {
+            usedKeys.add(result.id);
+
+            // 如果有dm值，记录下来（dm是中文默认值）
+            if (result.dm && typeof result.dm === 'string') {
+              usedKeysData[result.id] = result.dm;
+            }
+          }
+        },
+      });
+    } catch (error) {
+      console.error(`    # 处理文件失败: ${file}`, error);
+      if (error.loc) {
+        console.error(`    # 错误位置: 第${error.loc.line}行, 第${error.loc.column}列`);
+      }
+    }
+  });
+
+  return { usedKeys, usedKeysData };
+};
+
+// 读取翻译文件
+const readTranslationFiles = (localesFilePath, dashScope) => {
+  // 读取中文翻译文件
+  let zhCN = {};
+  try {
+    zhCN = fs.readJsonSync(`${localesFilePath}/zh-cn.json`);
+  } catch (error) {
+    console.log('    未找到zh-cn.json文件');
+  }
+
+  // 根据配置确定需要检查的语言文件
+  const languageFiles = {};
+  if (dashScope && dashScope.valueTranslateAppId) {
+    if (typeof dashScope.valueTranslateAppId === 'string') {
+      // 兼容旧版本配置，只检查英文
+      try {
+        languageFiles['en-us'] = fs.readJsonSync(`${localesFilePath}/en-us.json`);
+      } catch (error) {
+        console.log('    未找到en-us.json文件');
+      }
+    } else if (typeof dashScope.valueTranslateAppId === 'object') {
+      // 新版本配置，检查所有配置的语言
+      for (const language of Object.keys(dashScope.valueTranslateAppId)) {
+        try {
+          languageFiles[language] = fs.readJsonSync(`${localesFilePath}/${language}.json`);
+        } catch (error) {
+          console.log(`    未找到${language}.json文件`);
+        }
+      }
+    }
+  }
+
+  return { zhCN, languageFiles };
+};
+
+// 分析缺失和未使用的key
+const analyzeMissingAndUnusedKeys = (usedKeys, zhCN, languageFiles) => {
+  const zhCNKeys = new Set(Object.keys(zhCN));
+  const languageKeys = {};
+  for (const [language, content] of Object.entries(languageFiles)) {
+    languageKeys[language] = new Set(Object.keys(content));
+  }
+
+  // 找出缺失的key
+  const missingKeys = {
+    zhCN: Array.from(usedKeys).filter((key) => !zhCNKeys.has(key)),
+  };
+
+  for (const [language, keys] of Object.entries(languageKeys)) {
+    missingKeys[language] = Array.from(usedKeys).filter((key) => !keys.has(key));
+  }
+
+  // 找出多余的key
+  const unusedKeys = {
+    zhCN: Array.from(zhCNKeys).filter((key) => !usedKeys.has(key)),
+  };
+
+  for (const [language, keys] of Object.entries(languageKeys)) {
+    unusedKeys[language] = Array.from(keys).filter((key) => !usedKeys.has(key));
+  }
+
+  return { missingKeys, unusedKeys };
+};
+
+// 生成检查结果输出
+const generateCheckOutput = (missingKeys, unusedKeys) => {
+  const outputLines = [];
+  outputLines.push('=== 检查结果 ===');
+  outputLines.push('');
+  outputLines.push('1. 缺失的翻译key:');
+
+  if (missingKeys.zhCN.length > 0) {
+    outputLines.push('');
+    outputLines.push('zh-cn.json 缺失的key:');
+    missingKeys.zhCN.forEach((key) => outputLines.push(`    ${key}`));
+  } else {
+    outputLines.push('');
+    outputLines.push('zh-cn.json 没有缺失的key');
+  }
+
+  for (const [language, missing] of Object.entries(missingKeys)) {
+    if (language === 'zhCN') continue; // 跳过中文，已经处理过了
+
+    if (missing.length > 0) {
+      outputLines.push('');
+      outputLines.push(`${language}.json 缺失的key:`);
+      missing.forEach((key) => outputLines.push(`    ${key}`));
+    } else {
+      outputLines.push('');
+      outputLines.push(`${language}.json 没有缺失的key`);
+    }
+  }
+
+  outputLines.push('');
+  outputLines.push('2. 未使用的翻译key:');
+
+  if (unusedKeys.zhCN.length > 0) {
+    outputLines.push('');
+    outputLines.push('zh-cn.json 中未使用的key:');
+    unusedKeys.zhCN.forEach((key) => outputLines.push(`    ${key}`));
+  } else {
+    outputLines.push('');
+    outputLines.push('zh-cn.json 没有未使用的key');
+  }
+
+  for (const [language, unused] of Object.entries(unusedKeys)) {
+    if (language === 'zhCN') continue; // 跳过中文，已经处理过了
+
+    if (unused.length > 0) {
+      outputLines.push('');
+      outputLines.push(`${language}.json 中未使用的key:`);
+      unused.forEach((key) => outputLines.push(`    ${key}`));
+    } else {
+      outputLines.push('');
+      outputLines.push(`${language}.json 没有未使用的key`);
+    }
+  }
+
+  outputLines.push('');
+  outputLines.push('=== 检查完成 ===');
+
+  return outputLines;
+};
+
+// 处理输出和JSON文件生成
+const handleOutputAndJsonGeneration = (outputLines, missingKeys, unusedKeys, autoDeleteUnused) => {
+  // 判断是否需要生成JSON文件（自动删除模式下不生成日志文件）
+  if (outputLines.length > 100 && !autoDeleteUnused) {
+    // 生成JSON文件
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const jsonFileName = `check-result-${timestamp}.json`;
+
+    const jsonResult = {
+      timestamp: new Date().toISOString(),
+      summary: {
+        totalMissingKeys: Object.values(missingKeys).reduce((sum, keys) => sum + keys.length, 0),
+        totalUnusedKeys: Object.values(unusedKeys).reduce((sum, keys) => sum + keys.length, 0),
+        totalOutputLines: outputLines.length,
+      },
+      missingKeys,
+      unusedKeys,
+    };
+
+    try {
+      fs.writeJsonSync(jsonFileName, jsonResult, { spaces: 2 });
+
+      // 输出简化版本
+      console.log('\n=== 检查结果 ===');
+      console.log(`\n⚠️  输出内容较多(${outputLines.length}行)，详细结果已保存到: ${jsonFileName}`);
+      console.log('\n📊 概要信息:');
+      console.log(`   • 缺失的翻译key总数: ${jsonResult.summary.totalMissingKeys}`);
+      console.log(`   • 未使用的翻译key总数: ${jsonResult.summary.totalUnusedKeys}`);
+
+      // 显示各语言的统计
+      console.log('\n📋 各语言统计:');
+      console.log('   缺失的key:');
+      for (const [language, missing] of Object.entries(missingKeys)) {
+        const displayLang = language === 'zhCN' ? 'zh-cn' : language;
+        console.log(`     ${displayLang}.json: ${missing.length}个`);
+      }
+
+      console.log('   未使用的key:');
+      for (const [language, unused] of Object.entries(unusedKeys)) {
+        const displayLang = language === 'zhCN' ? 'zh-cn' : language;
+        console.log(`     ${displayLang}.json: ${unused.length}个`);
+      }
+
+      console.log('\n=== 检查完成 ===\n');
+    } catch (error) {
+      console.error(`\n❌ 生成JSON文件失败: ${error.message}`);
+      // 如果JSON文件生成失败，仍然输出完整结果（自动删除模式下不输出）
+      if (!autoDeleteUnused) {
+        outputLines.forEach((line) => console.log(line));
+      }
+    }
+  } else {
+    // 正常输出（自动删除模式下不输出日志）
+    if (!autoDeleteUnused) {
+      console.log('');
+      outputLines.forEach((line) => console.log(line));
+      console.log('');
+    }
+  }
+};
+
+// 处理未使用key的删除
+const handleUnusedKeysDeletion = async (
+  unusedKeys,
+  zhCN,
+  languageFiles,
+  localesFilePath,
+  autoDeleteUnused,
+) => {
+  const hasUnusedKeys = Object.values(unusedKeys).some((keys) => keys.length > 0);
+  if (!hasUnusedKeys) return;
+
+  let shouldDelete = false;
+
+  if (autoDeleteUnused) {
+    // 自动删除模式
+    shouldDelete = true;
+    console.log('    # 自动删除未使用的key...');
+  } else {
+    // 询问用户是否删除
+    const answer = await askQuestion('是否删除未使用的key？(y/n): ');
+    shouldDelete = answer === 'y' || answer === 'yes';
+  }
+
+  if (shouldDelete) {
+    // 删除zh-cn.json中未使用的key
+    if (unusedKeys.zhCN.length > 0) {
+      unusedKeys.zhCN.forEach((key) => {
+        delete zhCN[key];
+      });
+      fs.writeJsonSync(`${localesFilePath}/zh-cn.json`, zhCN, { spaces: 2 });
+      console.log(`    # 已从zh-cn.json中删除${unusedKeys.zhCN.length}个未使用的key`);
+    }
+
+    // 删除其他语言文件中未使用的key
+    for (const [language, unused] of Object.entries(unusedKeys)) {
+      if (language === 'zhCN') continue; // 跳过中文，已经处理过了
+
+      if (unused.length > 0) {
+        unused.forEach((key) => {
+          delete languageFiles[language][key];
+        });
+        fs.writeJsonSync(`${localesFilePath}/${language}.json`, languageFiles[language], {
+          spaces: 2,
+        });
+        console.log(`    # 已从${language}.json中删除${unused.length}个未使用的key`);
+      }
+    }
+  } else {
+    console.log('    # 已取消删除操作');
+  }
+};
+
+// 处理Excel生成的交互逻辑
+const handleExcelGeneration = async (missingKeys, usedKeysData, zhCN, params, autoDeleteUnused) => {
+  const hasAnyMissingKeys = Object.values(missingKeys).some((keys) => keys.length > 0);
+
+  if (!hasAnyMissingKeys || !params.medusa || autoDeleteUnused) {
+    if (hasAnyMissingKeys && !params.medusa && !autoDeleteUnused) {
+      console.log('\n=== 提示 ===');
+      console.log('    [提示] 检测到丢失的翻译key，但未配置medusa，无法生成Excel文件');
+      console.log('    [提示] 请在配置文件中添加medusa配置以启用Excel生成功能');
+    }
+    return;
+  }
+
+  console.log('\n=== Excel生成选项 ===');
+  const answer = await askQuestion('检测到丢失的翻译key，是否生成Excel文件用于翻译？(y/n): ');
+
+  if (answer !== 'y' && answer !== 'yes') {
+    console.log('    [取消] 已取消Excel文件生成');
+    return;
+  }
+
+  try {
+    // 让用户选择要生成Excel的语言
+    console.log('\n各语言缺失的翻译key数量：');
+    const languageOptions = [];
+
+    for (const [language, keys] of Object.entries(missingKeys)) {
+      if (keys.length > 0) {
+        const languageName = language === 'zhCN' ? 'zh-cn' : language;
+        console.log(`  ${languageName}: ${keys.length}个缺失key`);
+        languageOptions.push({ code: languageName, keys: keys, originalCode: language });
+      }
+    }
+
+    if (languageOptions.length === 0) {
+      console.log('  没有缺失的key');
+      return;
+    }
+
+    // 尝试使用inquirer进行交互式选择，如果不支持则回退到数字输入
+    let selectedLanguage;
+
+    try {
+      // 动态导入inquirer
+      const inquirer = await import('inquirer');
+
+      const choices = languageOptions.map((option) => ({
+        name: `${option.code} (${option.keys.length}个缺失key)`,
+        value: option,
+      }));
+
+      const result = await inquirer.default.prompt([
+        {
+          type: 'list',
+          name: 'selectedLanguage',
+          message: '请选择要生成Excel的语言（使用上下键选择，回车确认）：',
+          choices: choices,
+          pageSize: 10,
+        },
+      ]);
+
+      selectedLanguage = result.selectedLanguage;
+    } catch (error) {
+      if (error.isTtyError) {
+        // 回退到数字输入模式
+        console.log('\n当前环境不支持交互式选择，使用数字输入模式：');
+        languageOptions.forEach((option, index) => {
+          console.log(`  ${index + 1}. ${option.code} (${option.keys.length}个缺失key)`);
+        });
+
+        const languageAnswer = await askQuestion(
+          `请输入数字选择语言 (1-${languageOptions.length}): `,
+        );
+        const selectedIndex = parseInt(languageAnswer) - 1;
+
+        if (selectedIndex < 0 || selectedIndex >= languageOptions.length) {
+          console.log('    [取消] 选择无效，已取消Excel文件生成');
+          return;
+        }
+
+        selectedLanguage = languageOptions[selectedIndex];
+      } else {
+        throw error;
+      }
+    }
+
+    const missingKeysArray = selectedLanguage.keys;
+
+    console.log(
+      `\n已选择语言: ${selectedLanguage.code}，将为${missingKeysArray.length}个缺失key生成Excel`,
+    );
+
+    if (missingKeysArray.length > 0) {
+      // 构建自定义数据源，只包含缺失的key和对应的dm值
+      const customData = {};
+
+      console.log(`    [信息] 准备为${missingKeysArray.length}个缺失的key生成Excel`);
+
+      for (const key of missingKeysArray) {
+        customData[key] = {};
+
+        // 为每种语言设置数据
+        for (const [languageFile, columnName] of Object.entries(params.medusa.keyMap)) {
+          if (languageFile === 'zh-cn') {
+            // Simple Chinese列的逻辑
+            if (selectedLanguage.originalCode === 'zhCN') {
+              // 如果选择的是中文语言，使用dm值
+              const dmValue = usedKeysData[key] || '';
+              customData[key][languageFile] = dmValue;
+
+              if (dmValue) {
+                console.log(`    [数据] ${key} -> "${dmValue}"`);
+              } else {
+                console.log(`    [数据] ${key} -> (无dm值)`);
+              }
+            } else {
+              // 如果选择的是其他语言，从现有的中文翻译文件中获取值
+              const existingZhValue = zhCN[key] || usedKeysData[key] || '';
+              customData[key][languageFile] = existingZhValue;
+
+              if (existingZhValue) {
+                console.log(`    [数据] ${key} -> "${existingZhValue}" (来自zh-cn.json或dm)`);
+              } else {
+                console.log(`    [数据] ${key} -> (无中文值)`);
+              }
+            }
+          } else {
+            // 其他语言列为空，等待翻译
+            customData[key][languageFile] = '';
+          }
+        }
+      }
+
+      const excelPath = await generateMedusaExcel({
+        localesFilePath: params.localesFilePath,
+        medusa: params.medusa,
+        newKeys: missingKeysArray,
+        customData,
+      });
+
+      console.log(`    [完成] Excel文件已生成: ${excelPath}`);
+      console.log('    [提示] 请在Excel中完成翻译后，使用相应的导入功能更新翻译文件');
+    } else {
+      console.log('    [信息] 没有需要生成Excel的丢失key');
+    }
+  } catch (error) {
+    console.error(`    [错误] 生成Excel文件失败: ${error.message}`);
+    if (error.stack) {
+      console.error(error.stack);
+    }
+  }
+};
+
+// 检查翻译
+const check = async function (sourcePath, params) {
+  const {
+    fileType = '.tsx,.js,.ts,.jsx',
+    localesFilePath,
+    dashScope,
+    medusa,
+    autoDeleteUnused,
+  } = params;
+
+  // 扫描文件
+  const fileTypes = fileType.split(',').map((s) => s.trim());
+  const re = new RegExp(`(${fileTypes.map((ft) => ft.replace('.', '\\.')).join('|')})$`);
+  const files = find.fileSync(re, sourcePath);
+  console.log(`    # 检查${files.length}个${fileType}文件`);
+
+  // 收集使用的key和dm值
+  const { usedKeys, usedKeysData } = scanFilesAndCollectKeys(files);
+
+  // 读取翻译文件
+  const { zhCN, languageFiles } = readTranslationFiles(localesFilePath, dashScope);
+
+  // 分析缺失和未使用的key
+  const { missingKeys, unusedKeys } = analyzeMissingAndUnusedKeys(usedKeys, zhCN, languageFiles);
+
+  // 生成输出内容
+  const outputLines = generateCheckOutput(missingKeys, unusedKeys);
+
+  // 处理输出和JSON文件生成
+  handleOutputAndJsonGeneration(outputLines, missingKeys, unusedKeys, autoDeleteUnused);
+
+  // 处理未使用key的删除
+  await handleUnusedKeysDeletion(
+    unusedKeys,
+    zhCN,
+    languageFiles,
+    localesFilePath,
+    autoDeleteUnused,
+  );
+
+  // 处理Excel生成
+  await handleExcelGeneration(missingKeys, usedKeysData, zhCN, params, autoDeleteUnused);
+
+  // 返回结果，以便其他程序可能需要使用
+  const result = {
+    missingKeys,
+    unusedKeys,
+    usedKeysData, // 添加使用的key数据
+  };
+
+  return result;
+};
+
+// 还原国际化代码为中文
+const reverse = async function (sourcePath, params) {
+  const { fileType = '.tsx,.js,.ts,.jsx', localesFilePath, functionImportPath } = params;
+
+  console.log(`    [开始] 开始还原国际化代码为中文...`);
+
+  // 读取中文翻译文件
+  let zhCN = {};
+  try {
+    zhCN = fs.readJsonSync(`${localesFilePath}/zh-cn.json`);
+  } catch (error) {
+    console.log('    [警告] 未找到zh-cn.json文件，无法还原字符串key');
+  }
+
+  const fileTypes = fileType.split(',').map((s) => s.trim());
+  const re = new RegExp(`(${fileTypes.map((ft) => ft.replace('.', '\\.')).join('|')})$`);
+
+  // 检索文件
+  const files = find.fileSync(re, sourcePath);
+  console.log(`    [进度] 找到${files.length}个${fileType}文件需要处理`);
+
+  let totalReversed = 0;
+  let totalFilesModified = 0;
+
+  // 遍历所有文件
+  for (const file of files) {
+    try {
+      const code = fs.readFileSync(file, 'utf8');
+
+      // 解析文件
+      const ast = parseAST(code);
+      let hasChanges = false;
+      let reversedCount = 0;
+
+      // 遍历AST查找$i18n.get调用并替换
+      traverse(ast, {
+        CallExpression(path) {
+          const result = extractI18nKey(path.node);
+          if (result && result.id) {
+            let chineseText = null;
+
+            // 优先使用dm字段（defaultMessage）
+            if (result.dm) {
+              chineseText = result.dm;
+            }
+            // 如果没有dm字段，从zh-cn.json中查找
+            else if (zhCN[result.id]) {
+              chineseText = zhCN[result.id];
+            }
+
+            if (chineseText) {
+              // 替换为中文文本
+              path.replaceWith(t.stringLiteral(chineseText));
+              hasChanges = true;
+              reversedCount++;
+            }
+          }
+        },
+      });
+
+      // 如果有改动，写回文件
+      if (hasChanges) {
+        const newCode = generateCode(ast, code);
+        fs.writeFileSync(file, newCode);
+        totalFilesModified++;
+        totalReversed += reversedCount;
+        console.log(`    [完成] 文件 ${file} 还原了${reversedCount}处国际化代码`);
+      }
+    } catch (error) {
+      console.error(`    [错误] 处理文件失败: ${file}`, error);
+      if (error.loc) {
+        console.error(`    [错误] 错误位置: 第${error.loc.line}行, 第${error.loc.column}列`);
+      }
+    }
+  }
+
+  // 删除导入语句
+  console.log(`    [进度] 开始删除导入语句...`);
+  if (functionImportPath) {
+    console.log(`    [信息] 匹配的导入路径: ${functionImportPath}`);
+  } else {
+    console.log(`    [信息] 未配置functionImportPath，将删除所有$i18n导入语句`);
+  }
+  let importRemovedCount = 0;
+
+  for (const file of files) {
+    try {
+      const code = fs.readFileSync(file, 'utf8');
+      const ast = parseAST(code);
+      let hasImportChanges = false;
+
+      // 查找并删除 $i18n 的导入语句
+      traverse(ast, {
+        ImportDeclaration(path) {
+          const source = path.node.source.value;
+          const specifiers = path.node.specifiers;
+
+          // 检查是否是来自指定路径的 $i18n 导入（支持默认导入和命名导入）
+          const hasI18nImport = specifiers.some(
+            (spec) =>
+              (spec.type === 'ImportSpecifier' && spec.imported.name === '$i18n') ||
+              (spec.type === 'ImportDefaultSpecifier' && spec.local.name === '$i18n'),
+          );
+
+          // 添加调试信息
+          if (hasI18nImport) {
+            console.log(`    [调试] 找到$i18n导入语句:`);
+            console.log(`      - 导入路径: "${source}"`);
+            console.log(`      - 配置的functionImportPath: "${functionImportPath}"`);
+          }
+
+          // 检查导入路径是否匹配（如果未配置functionImportPath，则匹配所有）
+          const isMatchingPath =
+            !functionImportPath ||
+            source === functionImportPath ||
+            source.endsWith(functionImportPath.replace(/^@\//, '')) ||
+            functionImportPath.endsWith(source.replace(/^@\//, ''));
+
+          if (hasI18nImport) {
+            console.log(`      - 是否匹配路径: ${isMatchingPath}`);
+          }
+
+          if (hasI18nImport && isMatchingPath) {
+            // 移除 $i18n 的导入（支持默认导入和命名导入）
+            const remainingSpecifiers = specifiers.filter(
+              (spec) =>
+                !(
+                  (spec.type === 'ImportSpecifier' && spec.imported.name === '$i18n') ||
+                  (spec.type === 'ImportDefaultSpecifier' && spec.local.name === '$i18n')
+                ),
+            );
+
+            if (remainingSpecifiers.length === 0) {
+              // 如果没有其他导入，删除整个导入语句
+              path.remove();
+            } else {
+              // 更新导入语句，移除 $i18n
+              path.node.specifiers = remainingSpecifiers;
+            }
+            hasImportChanges = true;
+            console.log(`    [删除] 从 ${file} 中删除 $i18n 导入: ${source}`);
+          }
+        },
+      });
+
+      if (hasImportChanges) {
+        const newCode = generateCode(ast, code);
+        fs.writeFileSync(file, newCode);
+        importRemovedCount++;
+      }
+    } catch (error) {
+      console.error(`    [错误] 删除导入语句失败: ${file}`, error);
+    }
+  }
+
+  console.log(`    [完成] 已从${importRemovedCount}个文件中删除$i18n导入语句`);
+
+  console.log(`\n=== 还原完成 ===`);
+  console.log(`共处理了${files.length}个文件`);
+  console.log(`修改了${totalFilesModified}个文件`);
+  console.log(`还原了${totalReversed}处国际化代码`);
+
+  return {
+    totalFiles: files.length,
+    modifiedFiles: totalFilesModified,
+    reversedCount: totalReversed,
+  };
+};
+
+module.exports = {
+  init,
+  initMT,
+  patch,
+  patchMT,
+  check,
+  reverse,
+};