@agentscope-ai/i18n 1.0.0 → 1.0.2

package/lib/core/translator.js

@@ -4,35 +4,24 @@ const find = require('find');
 const { parse } = require('@babel/parser');
 const traverse = require('@babel/traverse').default;
 const generate = require('@babel/generator').default;
+const t = require('@babel/types');
 const { scanFiles, resolveFiles, injectImportStatement } = require('../utils/file-utils');
-const {
-  processFiles,
-  translateAndUpdateFiles,
-  singleTranslateAndUpdateFiles,
-  replaceKeysInFiles,
-} = require('./file-processor');
+const { processFiles, translateAndUpdateFiles, replaceKeysInFiles } = require('./file-processor');
 const { generateMdsPayload } = require('../utils/mds-payload');
 const { singleKeyTranslate, singleTranslate } = require('../utils/translation-utils');
-const {
-  extractI18nKey,
-  chnRegExp,
-  onlyContainsChinesePunctuation,
-  onlyContainsEmoji,
-  isI18nCall,
-  isInConsoleCall,
-} = require('../utils/ast-utils');
-const { askQuestion } = require('../utils/cli-utils');
-const {
-  shouldIgnoreLineByComment,
-  shouldIgnoreBlockByComment,
-  shouldIgnoreByComment,
-  shouldIgnoreFile,
-} = require('../utils/file-utils');
+const { extractI18nKey } = require('../utils/ast-utils');
 const { generateMedusaExcel } = require('../utils/excel-utils');
-// inquirer需要动态导入，因为它是ES模块
-const t = require('@babel/types');
+const {
+  scanFilesAndCollectKeys,
+  scanUntranslatedTexts,
+  readTranslationFiles,
+  analyzeMissingAndUnusedKeys,
+  generateCheckOutput,
+  handleOutputAndJsonGeneration,
+  handleUnusedKeysDeletion,
+  handleExcelGeneration,
+} = require('./checker');
 
-// 解析AST
 const parseAST = (code) => {
   return parse(code, {
     sourceType: 'module',
@@ -40,15 +29,11 @@ const parseAST = (code) => {
   });
 };
 
-// 生成代码
 const generateCode = (ast, originalCode) => {
   return generate(
     ast,
     {
-      jsescOption: {
-        minimal: true,
-        quotes: 'single',
-      },
+      jsescOption: { minimal: true, quotes: 'single' },
       retainLines: false,
       compact: 'auto',
     },
@@ -56,840 +41,109 @@ const generateCode = (ast, originalCode) => {
   ).code;
 };
 
-// 初始化翻译
-const init = async function (sourcePath, params) {
-  try {
-    const {
-      fileType = '.tsx,.js,.ts,.jsx',
-      localesFilePath,
-      keyPrefix,
-      doNotTranslateFiles,
-      functionImportPath,
-      i18nFilePath,
-      dashScope,
-      medusa,
-      skipConfirm,
-    } = 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,
-      skipConfirm,
-    );
+const copyI18nFile = (i18nFilePath, isUpdate) => {
+  if (!i18nFilePath) return;
 
-    // 如果配置了i18nFilePath，复制i18n.ts文件
-    if (i18nFilePath) {
-      const sourceI18nPath = path.join(__dirname, '../i18n.ts');
-      const targetI18nPath = path.join(i18nFilePath, 'index.ts');
+  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;
+  if (isUpdate && fs.existsSync(targetI18nPath)) {
+    console.log(`    [提示] i18n.ts文件已存在于 ${targetI18nPath}，跳过复制`);
+    return;
   }
+
+  fs.ensureDirSync(i18nFilePath);
+  fs.copyFileSync(sourceI18nPath, targetI18nPath);
+  console.log(`    [完成] i18n.ts文件已复制到 ${targetI18nPath}`);
 };
 
-// 使用MT方式的初始化翻译
-const initMT = async function (sourcePath, params) {
+/**
+ * 统一的翻译入口。合并了原来的 init / initMT / patch / patchMT 四个函数。
+ * @param {string} sourcePath - 源文件目录
+ * @param {object} config - 完整的配置对象
+ * @param {object} options - { isUpdate, engine }
+ */
+const runTranslation = async (sourcePath, config, { isUpdate = false, engine = 'mt' } = {}) => {
   try {
     const {
       fileType = '.tsx,.js,.ts,.jsx',
-      localesFilePath,
       keyPrefix,
       doNotTranslateFiles,
-      functionImportPath,
-      i18nFilePath,
       dashScope,
-      medusa,
-      skipConfirm,
-    } = params;
+      i18nFilePath,
+    } = config;
 
     if (!keyPrefix) {
       throw new Error('keyPrefix is required in params');
     }
 
-    if (!dashScope || !dashScope.apiKey) {
+    if (engine === 'mt' && (!dashScope || !dashScope.apiKey)) {
       throw new Error('dashScope.apiKey is required for MT translation');
     }
 
-    console.log('    [信息] 使用MT方式进行单条翻译...');
+    const engineLabel = engine === 'agent' ? 'Agent' : 'MT';
+    const modeLabel = isUpdate ? '增量翻译' : '初始化翻译';
+    console.log(`    [信息] 使用${engineLabel}方式进行${modeLabel}...`);
 
     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,
-      skipConfirm,
-    );
-
-    // 如果配置了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,
-    skipConfirm,
-  } = 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,
-    skipConfirm,
-  );
-
-  // 如果配置了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,
-    skipConfirm,
-  } = 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,
-    skipConfirm,
-  );
-
-  // 如果配置了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}，跳过复制`);
+    if (isUpdate) {
+      console.log(`    # 检查${files.length}个${fileType}文件`);
     }
-  }
-
-  console.log(`    新增文案MT翻译补充完成！新增${newKeysCount}条翻译文案`);
-};
 
-// 扫描文件并收集使用的key和dm值
-const scanFilesAndCollectKeys = (files) => {
-  const usedKeys = new Set();
-  const usedKeysData = {}; // 存储key对应的dm值（中文默认值）
+    const { i18n, fileCodeMap, needImportFiles } = await processFiles(files, config);
 
-  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 };
-};
-
-// 扫描未翻译的中文文案（未被 $i18n.get 包裹的中文字符串）
-const scanUntranslatedTexts = (files, doNotTranslateFiles) => {
-  const untranslatedTexts = [];
-
-  const filteredFiles = files.filter((file) => {
-    if (shouldIgnoreFile(file, doNotTranslateFiles || [])) return false;
-    if (shouldIgnoreByComment(file)) return false;
-    return true;
-  });
-
-  filteredFiles.forEach((file) => {
-    try {
-      const code = fs.readFileSync(file, 'utf8');
-      const ast = parseAST(code);
-
-      const shouldIgnoreNode = (nodePath) => {
-        if (!nodePath.node.loc) return false;
-        const lineNumber = nodePath.node.loc.start.line;
-        return (
-          shouldIgnoreLineByComment(file, lineNumber) ||
-          shouldIgnoreBlockByComment(file, lineNumber)
-        );
-      };
-
-      traverse(ast, {
-        StringLiteral(astPath) {
-          const { value } = astPath.node;
-          if (
-            chnRegExp.test(value) &&
-            !isI18nCall(astPath.parent) &&
-            !astPath.findParent((p) => isI18nCall(p.node)) &&
-            !isInConsoleCall(astPath) &&
-            !shouldIgnoreNode(astPath) &&
-            !onlyContainsChinesePunctuation(value) &&
-            !onlyContainsEmoji(value)
-          ) {
-            untranslatedTexts.push({
-              file,
-              line: astPath.node.loc?.start.line,
-              column: astPath.node.loc?.start.column,
-              type: 'StringLiteral',
-              text: value,
-            });
-          }
-        },
-        TemplateLiteral(astPath) {
-          if (
-            !isI18nCall(astPath.parent) &&
-            !astPath.findParent((p) => isI18nCall(p.node)) &&
-            !isInConsoleCall(astPath) &&
-            !shouldIgnoreNode(astPath)
-          ) {
-            const staticParts = astPath.node.quasis.map((q) => q.value.raw).join('');
-            if (
-              chnRegExp.test(staticParts) &&
-              !onlyContainsChinesePunctuation(staticParts) &&
-              !onlyContainsEmoji(staticParts)
-            ) {
-              const fullText = astPath.node.quasis
-                .map((q, i) => {
-                  const expr = astPath.node.expressions[i];
-                  const exprStr = expr ? `\${${generate(expr, { compact: true }).code}}` : '';
-                  return q.value.raw + exprStr;
-                })
-                .join('');
-              untranslatedTexts.push({
-                file,
-                line: astPath.node.loc?.start.line,
-                column: astPath.node.loc?.start.column,
-                type: 'TemplateLiteral',
-                text: fullText,
-              });
-            }
-          }
-        },
-        JSXText(astPath) {
-          const { value } = astPath.node;
-          if (
-            chnRegExp.test(value) &&
-            !isI18nCall(astPath.parent) &&
-            !astPath.findParent((p) => isI18nCall(p.node)) &&
-            !isInConsoleCall(astPath) &&
-            !shouldIgnoreNode(astPath) &&
-            !onlyContainsChinesePunctuation(value) &&
-            !onlyContainsEmoji(value)
-          ) {
-            const trimmedValue = value.replace(/^\s+|\s+$/g, '');
-            if (trimmedValue) {
-              untranslatedTexts.push({
-                file,
-                line: astPath.node.loc?.start.line,
-                column: astPath.node.loc?.start.column,
-                type: 'JSXText',
-                text: trimmedValue,
-              });
-            }
-          }
-        },
-      });
-    } catch (error) {
-      console.error(`    # 扫描未翻译文案失败: ${file}`, error.message);
-    }
-  });
-
-  return untranslatedTexts;
-};
-
-// 读取翻译文件
-const readTranslationFiles = (localesFilePath, dashScope, checkLanguages) => {
-  // 读取中文翻译文件
-  let zhCN = {};
-  try {
-    zhCN = fs.readJsonSync(`${localesFilePath}/zh-cn.json`);
-  } catch (error) {
-    console.log('    未找到zh-cn.json文件');
-  }
-
-  // 确定需要检查的语言列表，优先级：check.languages > dashScope.valueTranslateAppId
-  let languages = [];
-
-  if (Array.isArray(checkLanguages) && checkLanguages.length > 0) {
-    // 从 check.languages 配置中获取，排除 zh-cn（已单独处理）
-    languages = checkLanguages.filter((lang) => lang !== 'zh-cn');
-  } else if (dashScope && dashScope.valueTranslateAppId) {
-    if (typeof dashScope.valueTranslateAppId === 'string') {
-      languages = ['en-us'];
-    } else if (typeof dashScope.valueTranslateAppId === 'object') {
-      languages = Object.keys(dashScope.valueTranslateAppId);
-    }
-  }
-
-  const languageFiles = {};
-  for (const language of languages) {
-    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, untranslatedTexts) => {
-  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('3. 未翻译的中文文案:');
-
-  if (untranslatedTexts.length > 0) {
-    outputLines.push('');
-    outputLines.push(`共发现 ${untranslatedTexts.length} 条未翻译的中文文案:`);
-    untranslatedTexts.forEach((item) => {
-      outputLines.push(`    ${item.file}:${item.line}:${item.column}  "${item.text}"`);
+    const newKeysCount = await translateAndUpdateFiles(i18n, config, {
+      isUpdate,
+      fileCodeMap,
+      needImportFiles,
+      engine,
     });
-  } else {
-    outputLines.push('');
-    outputLines.push('没有发现未翻译的中文文案');
-  }
-
-  outputLines.push('');
-  outputLines.push('=== 检查完成 ===');
 
-  return outputLines;
-};
+    copyI18nFile(i18nFilePath, isUpdate);
 
-// 处理输出和JSON文件生成
-const handleOutputAndJsonGeneration = (
-  outputLines,
-  missingKeys,
-  unusedKeys,
-  untranslatedTexts,
-  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),
-        totalUntranslatedTexts: untranslatedTexts.length,
-        totalOutputLines: outputLines.length,
-      },
-      missingKeys,
-      unusedKeys,
-      untranslatedTexts,
-    };
+    const resultMsg = isUpdate
+      ? `新增文案${engineLabel}翻译补充完成！新增${newKeysCount}条翻译文案`
+      : `${modeLabel}: ${sourcePath} 目录下文件中文文案提取、替换和${engineLabel}翻译成功！`;
+    console.log(`    ${resultMsg}`);
 
-    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(`   • 未翻译的中文文案总数: ${jsonResult.summary.totalUntranslatedTexts}`);
-
-      // 显示各语言的统计
-      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}个`);
-      }
-
-      if (untranslatedTexts.length > 0) {
-        console.log(`   未翻译的中文文案: ${untranslatedTexts.length}条`);
-      }
-
-      console.log('\n=== 检查完成 ===\n');
-    } catch (error) {
-      console.error(`\n❌ 生成JSON文件失败: ${error.message}`);
-      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');
-    }
+    return newKeysCount;
   } catch (error) {
-    console.error(`    [错误] 生成Excel文件失败: ${error.message}`);
-    if (error.stack) {
-      console.error(error.stack);
-    }
+    console.error('    [错误] 翻译失败:', error);
+    throw error;
   }
 };
 
-// 检查翻译
 const check = async function (sourcePath, params) {
   const {
     fileType = '.tsx,.js,.ts,.jsx',
     localesFilePath,
     dashScope,
-    medusa,
     autoDeleteUnused,
     summaryOnly,
     doNotTranslateFiles,
     check: checkConfig,
+    callExpression,
   } = params;
 
   const checkLanguages = checkConfig?.languages;
 
-  // 扫描文件
   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 { usedKeys, usedKeysData } = scanFilesAndCollectKeys(files, callExpression);
   const { zhCN, languageFiles } = readTranslationFiles(localesFilePath, dashScope, checkLanguages);
-
-  // 分析缺失和未使用的key
   const { missingKeys, unusedKeys } = analyzeMissingAndUnusedKeys(usedKeys, zhCN, languageFiles);
 
-  // 扫描未翻译的中文文案
   console.log(`    # 扫描未翻译的中文文案...`);
-  const untranslatedTexts = scanUntranslatedTexts(files, doNotTranslateFiles);
+  const untranslatedTexts = scanUntranslatedTexts(files, doNotTranslateFiles, callExpression);
   if (untranslatedTexts.length > 0) {
     console.log(`    # 发现 ${untranslatedTexts.length} 条未翻译的中文文案`);
   } else {
     console.log(`    # 未发现未翻译的中文文案`);
   }
 
-  // summaryOnly 模式：只输出各语言缺失的key数量，不做删除/生成等操作
   if (summaryOnly) {
     console.log('');
     console.log('=== 翻译缺失统计 ===');
@@ -932,44 +186,24 @@ const check = async function (sourcePath, params) {
     return { missingKeys, unusedKeys, usedKeysData, untranslatedTexts };
   }
 
-  // 完整模式：输出详情、删除未使用key、生成Excel等
   const outputLines = generateCheckOutput(missingKeys, unusedKeys, untranslatedTexts);
-
-  handleOutputAndJsonGeneration(
-    outputLines,
-    missingKeys,
-    unusedKeys,
-    untranslatedTexts,
-    autoDeleteUnused,
-  );
-
-  await handleUnusedKeysDeletion(
-    unusedKeys,
-    zhCN,
-    languageFiles,
-    localesFilePath,
-    autoDeleteUnused,
-  );
-
+  handleOutputAndJsonGeneration(outputLines, missingKeys, unusedKeys, untranslatedTexts, autoDeleteUnused);
+  await handleUnusedKeysDeletion(unusedKeys, zhCN, languageFiles, localesFilePath, autoDeleteUnused);
   await handleExcelGeneration(missingKeys, usedKeysData, zhCN, params, autoDeleteUnused);
 
-  const result = {
-    missingKeys,
-    unusedKeys,
-    usedKeysData,
-    untranslatedTexts,
-  };
-
-  return result;
+  return { missingKeys, unusedKeys, usedKeysData, untranslatedTexts };
 };
 
-// 还原国际化代码为中文
 const reverse = async function (sourcePath, params) {
-  const { fileType = '.tsx,.js,.ts,.jsx', localesFilePath, functionImportPath } = params;
+  const { fileType = '.tsx,.js,.ts,.jsx', localesFilePath, functionImportPath, callExpression } =
+    params;
+  const importName =
+    (callExpression && callExpression.importName) ||
+    (callExpression && callExpression.functionName) ||
+    '$i18n';
 
   console.log(`    [开始] 开始还原国际化代码为中文...`);
 
-  // 读取中文翻译文件
   let zhCN = {};
   try {
     zhCN = fs.readJsonSync(`${localesFilePath}/zh-cn.json`);
@@ -979,42 +213,25 @@ const reverse = async function (sourcePath, 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}文件需要处理`);
 
   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);
+          const result = extractI18nKey(path.node, callExpression);
           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];
-            }
-
+            const chineseText = result.dm || zhCN[result.id] || null;
             if (chineseText) {
-              // 替换为中文文本
               path.replaceWith(t.stringLiteral(chineseText));
               hasChanges = true;
               reversedCount++;
@@ -1023,7 +240,6 @@ const reverse = async function (sourcePath, params) {
         },
       });
 
-      // 如果有改动，写回文件
       if (hasChanges) {
         const newCode = generateCode(ast, code);
         fs.writeFileSync(file, newCode);
@@ -1039,13 +255,7 @@ const reverse = async function (sourcePath, params) {
     }
   }
 
-  // 删除导入语句
   console.log(`    [进度] 开始删除导入语句...`);
-  if (functionImportPath) {
-    console.log(`    [信息] 匹配的导入路径: ${functionImportPath}`);
-  } else {
-    console.log(`    [信息] 未配置functionImportPath，将删除所有$i18n导入语句`);
-  }
   let importRemovedCount = 0;
 
   for (const file of files) {
@@ -1054,56 +264,38 @@ const reverse = async function (sourcePath, params) {
       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'),
+              (spec.type === 'ImportSpecifier' && spec.imported.name === importName) ||
+              (spec.type === 'ImportDefaultSpecifier' && spec.local.name === importName),
           );
 
-          // 添加调试信息
-          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')
+                  (spec.type === 'ImportSpecifier' && spec.imported.name === importName) ||
+                  (spec.type === 'ImportDefaultSpecifier' && spec.local.name === importName)
                 ),
             );
 
             if (remainingSpecifiers.length === 0) {
-              // 如果没有其他导入，删除整个导入语句
               path.remove();
             } else {
-              // 更新导入语句，移除 $i18n
               path.node.specifiers = remainingSpecifiers;
             }
             hasImportChanges = true;
-            console.log(`    [删除] 从 ${file} 中删除 $i18n 导入: ${source}`);
           }
         },
       });
@@ -1118,23 +310,18 @@ const reverse = async function (sourcePath, params) {
     }
   }
 
-  console.log(`    [完成] 已从${importRemovedCount}个文件中删除$i18n导入语句`);
+  console.log(`    [完成] 已从${importRemovedCount}个文件中删除${importName}导入语句`);
 
   console.log(`\n=== 还原完成 ===`);
   console.log(`共处理了${files.length}个文件`);
   console.log(`修改了${totalFilesModified}个文件`);
   console.log(`还原了${totalReversed}处国际化代码`);
 
-  return {
-    totalFiles: files.length,
-    modifiedFiles: totalFilesModified,
-    reversedCount: totalReversed,
-  };
+  return { totalFiles: files.length, modifiedFiles: totalFilesModified, reversedCount: totalReversed };
 };
 
 /**
- * translate: 提取中文 → AI翻译 → 写locale文件 → 生成mds-payload.json
- * 不会修改源代码，是三步工作流的第一步。
+ * translate: 三步工作流 Step 1 — 只生成 locale 文件，不修改源码
  */
 const translate = async function (sourcePath, params) {
   try {
@@ -1148,12 +335,8 @@ const translate = async function (sourcePath, params) {
       file: singleFile,
     } = params;
 
-    if (!keyPrefix) {
-      throw new Error('keyPrefix is required in params');
-    }
-    if (!dashScope || !dashScope.apiKey) {
-      throw new Error('dashScope.apiKey is required for translation');
-    }
+    if (!keyPrefix) throw new Error('keyPrefix is required in params');
+    if (!dashScope || !dashScope.apiKey) throw new Error('dashScope.apiKey is required for translation');
 
     console.log('');
     console.log('=== [Step 1/3] translate ===');
@@ -1175,11 +358,7 @@ const translate = async function (sourcePath, params) {
 
     const zhCNPath = `${localesFilePath}/zh-cn.json`;
     let existingZhCN = {};
-    try {
-      existingZhCN = fs.readJsonSync(zhCNPath);
-    } catch {
-      // first run
-    }
+    try { existingZhCN = fs.readJsonSync(zhCNPath); } catch { /* first run */ }
     const finalZhCN = { ...existingZhCN, ...zhCN };
     fs.ensureDirSync(localesFilePath);
     fs.writeJsonSync(zhCNPath, finalZhCN, { spaces: 2 });
@@ -1191,32 +370,20 @@ const translate = async function (sourcePath, params) {
     for (const [language, translatedI18n] of Object.entries(translatedResults)) {
       const languagePath = `${localesFilePath}/${language}.json`;
       let existing = {};
-      try {
-        existing = fs.readJsonSync(languagePath);
-      } catch {
-        // first run
-      }
+      try { existing = fs.readJsonSync(languagePath); } catch { /* first run */ }
       fs.writeJsonSync(languagePath, { ...existing, ...translatedI18n }, { spaces: 2 });
       console.log(`    [完成] 更新 ${language}.json`);
     }
 
     const newKeys = Object.keys(zhCN);
 
-    generateMdsPayload({
-      localesFilePath,
-      appName: medusa?.appName,
-      filterKeys: newKeys,
-    });
+    generateMdsPayload({ localesFilePath, appName: medusa?.appName, filterKeys: newKeys });
 
     const statePath = path.resolve(localesFilePath, '.i18n-state.json');
-    fs.writeJsonSync(
-      statePath,
-      { keyMap, newKeys, sourcePath, timestamp: new Date().toISOString() },
-      { spaces: 2 },
-    );
+    fs.writeJsonSync(statePath, { keyMap, newKeys, sourcePath, timestamp: new Date().toISOString() }, { spaces: 2 });
     console.log(`    [完成] 翻译状态已保存到 ${statePath}`);
 
-    if (medusa && medusa.appName && medusa.group && medusa.keyMap) {
+    if (medusa && medusa.appName && medusa.keyMap) {
       try {
         await generateMedusaExcel({ localesFilePath, medusa, newKeys });
       } catch (error) {
@@ -1237,8 +404,7 @@ const translate = async function (sourcePath, params) {
 };
 
 /**
- * replaceOnly: 将代码中的中文替换为 $i18n.get 调用。
- * 依赖 translate 步骤保存的 .i18n-state.json，是三步工作流的第三步。
+ * replaceOnly: 三步工作流 Step 3 — 用 .i18n-state.json 替换源码
  */
 const replaceOnly = async function (sourcePath, params) {
   try {
@@ -1249,16 +415,20 @@ const replaceOnly = async function (sourcePath, params) {
       doNotTranslateFiles,
       functionImportPath,
       i18nFilePath,
+      callExpression,
       file: singleFile,
     } = params;
 
-    if (!keyPrefix) {
-      throw new Error('keyPrefix is required in params');
-    }
+    const callDisplayName =
+      callExpression && callExpression.functionName
+        ? `${callExpression.functionName}()`
+        : `${(callExpression && callExpression.objectName) || '$i18n'}.${(callExpression && callExpression.methodName) || 'get'}()`;
+
+    if (!keyPrefix) throw new Error('keyPrefix is required in params');
 
     console.log('');
     console.log('=== [Step 3/3] replace ===');
-    console.log('    将代码中的中文替换为 $i18n.get 调用');
+    console.log(`    将代码中的中文替换为 ${callDisplayName} 调用`);
     console.log('');
 
     const statePath = path.resolve(localesFilePath, '.i18n-state.json');
@@ -1275,31 +445,23 @@ const replaceOnly = async function (sourcePath, params) {
     const { fileCodeMap, needImportFiles } = await processFiles(files, params);
 
     console.log(`    [进度] 开始替换文件中的key...`);
-    await replaceKeysInFiles(sourcePath, keyMap, fileType, fileCodeMap);
+    await replaceKeysInFiles(sourcePath, keyMap, fileType, fileCodeMap, callExpression);
 
     if (needImportFiles.size > 0 && functionImportPath) {
       console.log(`    [进度] 开始添加导入语句...`);
       needImportFiles.forEach((file) => {
-        injectImportStatement(file, functionImportPath);
+        injectImportStatement(file, functionImportPath, callExpression);
       });
       console.log(`    [完成] 已为${needImportFiles.size}个文件添加导入语句`);
     }
 
-    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}`);
-      }
-    }
+    copyI18nFile(i18nFilePath, true);
 
     fs.removeSync(statePath);
     console.log(`    [完成] 已清理临时状态文件`);
 
     console.log('');
-    console.log('    ✅ replace 完成！代码中的中文已替换为 $i18n.get 调用');
+    console.log(`    ✅ replace 完成！代码中的中文已替换为 ${callDisplayName} 调用`);
     console.log('');
   } catch (error) {
     console.error('    [错误] replace 失败:', error);
@@ -1308,10 +470,7 @@ const replaceOnly = async function (sourcePath, params) {
 };
 
 module.exports = {
-  init,
-  initMT,
-  patch,
-  patchMT,
+  runTranslation,
   check,
   reverse,
   translate,