@agentscope-ai/i18n 1.0.1 → 1.0.2

package/lib/core/file-processor.js

@@ -11,19 +11,23 @@ const {
   singleKeyTranslate,
   singleTranslate,
 } = require('../utils/translation-utils');
-const { extractStringValue } = require('../utils/ast-utils');
+const { extractStringValue, isMatchingCallee } = require('../utils/ast-utils');
 const { askQuestion } = require('../utils/cli-utils');
 const { generateMedusaExcel } = require('../utils/excel-utils');
 const { generateMdsPayload } = require('../utils/mds-payload');
 const parseJSX = require('../parse-jsx');
 
-// 提取共用的文案处理函数
+const ENGINES = {
+  mt: { keyTranslate: singleKeyTranslate, valueTranslate: singleTranslate },
+  agent: { keyTranslate: batchKeyTranslate, valueTranslate: batchTranslate },
+};
+
 const processFiles = async (files, params) => {
   console.log(`    [开始] 提取和替换文件中的中文内容...`);
 
   const { keyPrefix, functionImportPath } = params;
-  const fileCodeMap = new Map(); // 存储文件路径和替换后的代码的映射
-  const needImportFiles = new Set(); // 存储需要添加导入语句的文件
+  const fileCodeMap = new Map();
+  const needImportFiles = new Set();
 
   const promises = files.map((file) => {
     if (/(\.js|\.ts|\.tsx|\.jsx)$/i.test(file)) {
@@ -51,169 +55,42 @@ const processFiles = async (files, params) => {
   return { i18n, fileCodeMap, needImportFiles };
 };
 
-// 提取共用的翻译和文件更新函数
-const translateAndUpdateFiles = async (
-  i18n,
-  path,
-  localesFilePath,
-  fileType,
-  fileCodeMap,
-  needImportFiles,
-  functionImportPath,
+/**
+ * 统一的翻译和文件更新函数。通过 engine 参数（'mt' | 'agent'）选择翻译策略。
+ */
+const translateAndUpdateFiles = async (i18n, config, {
   isUpdate = false,
-  dashScope,
-  medusa,
-  skipConfirm = false,
-) => {
-  if (Object.keys(i18n).length === 0) {
-    console.log('    [提示] 没有找到需要提取的文案');
-    return;
-  }
-
-  // 生成临时的key.json文件
-  const keyJsonPath = `${localesFilePath}/key.json`;
-  fs.ensureDirSync(localesFilePath);
-  fs.writeJsonSync(keyJsonPath, i18n, { spaces: 2 });
-  console.log(`    [进度] 生成临时key.json文件，共${Object.keys(i18n).length}条文案`);
-
-  // 调用key翻译
-  console.log(`    [进度] AI正在翻译key...请稍后`);
-  const { keyMap, zhCN } = await batchKeyTranslate(i18n, dashScope);
-
-  // 更新zh-cn.json
-  const zhCNPath = `${localesFilePath}/zh-cn.json`;
-  let existingZhCN = {};
-  if (isUpdate) {
-    try {
-      existingZhCN = fs.readJsonSync(zhCNPath);
-    } catch (error) {
-      console.log('    [提示] 未找到现有的zh-cn.json文件，将创建新文件');
-    }
-  }
-  const finalZhCN = isUpdate ? { ...existingZhCN, ...zhCN } : zhCN;
-  fs.writeJsonSync(zhCNPath, finalZhCN, { spaces: 2 });
-  console.log(`    [完成] ${isUpdate ? '更新' : '生成'}zh-cn.json文件成功`);
-
-  // 调用value翻译生成多语言文件
-  console.log(`    [进度] AI正在翻译value...请稍后`);
-  const translatedResults = await batchTranslate(zhCN, dashScope);
-
-  // 为每种语言生成对应的翻译文件
-  const generatedFiles = [];
-  for (const [language, translatedI18n] of Object.entries(translatedResults)) {
-    const languagePath = `${localesFilePath}/${language}.json`;
-    let existingLanguage = {};
-
-    if (isUpdate) {
-      try {
-        existingLanguage = fs.readJsonSync(languagePath);
-      } catch (error) {
-        console.log(`    [提示] 未找到现有的${language}.json文件，将创建新文件`);
-      }
-    }
-
-    const finalLanguage = isUpdate ? { ...existingLanguage, ...translatedI18n } : translatedI18n;
-    fs.writeJsonSync(languagePath, finalLanguage, { spaces: 2 });
-    console.log(`    [完成] ${isUpdate ? '更新' : '生成'}${language}.json文件成功`);
-    generatedFiles.push(languagePath);
-  }
-
-  // 提示用户检查翻译文件
-  console.log('\n=== 翻译文件已生成 ===');
-  console.log('请检查以下文件：');
-  console.log(`1. ${zhCNPath}`);
-  generatedFiles.forEach((file, index) => {
-    console.log(`${index + 2}. ${file}`);
-  });
-
-  let shouldReplace = skipConfirm;
-  if (!skipConfirm) {
-    const answer = await askQuestion('翻译文件检查无误后，是否继续替换代码中的文案？(y/n): ');
-    shouldReplace = answer === 'y' || answer === 'yes';
-  } else {
-    console.log('    [跳过确认] 自动继续替换代码中的文案');
-  }
-
-  if (shouldReplace) {
-    // 替换文件中的key
-    console.log(`    [进度] 开始替换文件中的key...`);
-    await replaceKeysInFiles(path, keyMap, fileType, fileCodeMap);
-
-    // 添加导入语句
-    if (needImportFiles.size > 0) {
-      console.log(`    [进度] 开始添加导入语句...`);
-      needImportFiles.forEach((file) => {
-        injectImportStatement(file, functionImportPath);
-      });
-      console.log(`    [完成] 已为${needImportFiles.size}个文件添加导入语句`);
-    }
-
-    console.log('    [完成] 代码替换完成！');
-  } else {
-    console.log('    [取消] 已取消代码替换操作');
-  }
-
-  // 询问是否生成medusa excel文件
-  if (medusa && medusa.appName && medusa.keyMap) {
-    let shouldGenExcel = skipConfirm;
-    if (!skipConfirm) {
-      const excelAnswer = await askQuestion('是否需要生成medusa excel文件？(y/n): ');
-      shouldGenExcel = excelAnswer === 'y' || excelAnswer === 'yes';
-    } else {
-      console.log('    [跳过确认] 自动生成medusa excel文件');
-    }
-    if (shouldGenExcel) {
-      try {
-        const newKeys = Object.keys(zhCN); // 新增的key
-        await generateMedusaExcel({
-          localesFilePath,
-          medusa,
-          newKeys,
-        });
-      } catch (error) {
-        console.error('    [错误] 生成medusa excel文件失败:', error.message);
-      }
-    } else {
-      console.log('    [取消] 已取消生成medusa excel文件');
-    }
-  }
-
-  fs.removeSync(keyJsonPath);
-  console.log(`    [提示] key.json文件已保留用于调试`);
-
-  return Object.keys(zhCN).length;
-};
-
-// 单条翻译和文件更新函数（使用MT方式）
-const singleTranslateAndUpdateFiles = async (
-  i18n,
-  path,
-  localesFilePath,
-  fileType,
   fileCodeMap,
   needImportFiles,
-  functionImportPath,
-  isUpdate = false,
-  dashScope,
-  medusa,
-  skipConfirm = false,
-) => {
+  engine = 'mt',
+} = {}) => {
+  const {
+    targetPath: sourcePath,
+    localesFilePath,
+    fileType = '.tsx,.js,.ts,.jsx',
+    functionImportPath,
+    dashScope,
+    medusa,
+    skipConfirm = false,
+    callExpression,
+  } = config;
+
   if (Object.keys(i18n).length === 0) {
     console.log('    [提示] 没有找到需要提取的文案');
-    return;
+    return 0;
   }
 
-  // 生成临时的key.json文件
+  const { keyTranslate, valueTranslate } = ENGINES[engine] || ENGINES.mt;
+  const engineLabel = engine === 'agent' ? 'Agent' : 'MT';
+
   const keyJsonPath = `${localesFilePath}/key.json`;
   fs.ensureDirSync(localesFilePath);
   fs.writeJsonSync(keyJsonPath, i18n, { spaces: 2 });
   console.log(`    [进度] 生成临时key.json文件，共${Object.keys(i18n).length}条文案`);
 
-  // 调用单条key翻译
-  console.log(`    [进度] 使用MT方式逐条翻译key...请稍后`);
-  const { keyMap, zhCN } = await singleKeyTranslate(i18n, dashScope);
+  console.log(`    [进度] 使用${engineLabel}方式翻译key...请稍后`);
+  const { keyMap, zhCN } = await keyTranslate(i18n, dashScope);
 
-  // 更新zh-cn.json
   const zhCNPath = `${localesFilePath}/zh-cn.json`;
   let existingZhCN = {};
   if (isUpdate) {
@@ -227,11 +104,9 @@ const singleTranslateAndUpdateFiles = async (
   fs.writeJsonSync(zhCNPath, finalZhCN, { spaces: 2 });
   console.log(`    [完成] ${isUpdate ? '更新' : '生成'}zh-cn.json文件成功`);
 
-  // 调用单条value翻译生成多语言文件
-  console.log(`    [进度] 使用MT方式逐条翻译value...请稍后`);
-  const translatedResults = await singleTranslate(zhCN, dashScope);
+  console.log(`    [进度] 使用${engineLabel}方式翻译value...请稍后`);
+  const translatedResults = await valueTranslate(zhCN, dashScope);
 
-  // 为每种语言生成对应的翻译文件
   const generatedFiles = [];
   for (const [language, translatedI18n] of Object.entries(translatedResults)) {
     const languagePath = `${localesFilePath}/${language}.json`;
@@ -251,8 +126,7 @@ const singleTranslateAndUpdateFiles = async (
     generatedFiles.push(languagePath);
   }
 
-  // 提示用户检查翻译文件
-  console.log('\n=== 翻译文件已生成（MT方式） ===');
+  console.log(`\n=== 翻译文件已生成（${engineLabel}方式） ===`);
   console.log('请检查以下文件：');
   console.log(`1. ${zhCNPath}`);
   generatedFiles.forEach((file, index) => {
@@ -268,15 +142,13 @@ const singleTranslateAndUpdateFiles = async (
   }
 
   if (shouldReplace) {
-    // 替换文件中的key
     console.log(`    [进度] 开始替换文件中的key...`);
-    await replaceKeysInFiles(path, keyMap, fileType, fileCodeMap);
+    await replaceKeysInFiles(sourcePath, keyMap, fileType, fileCodeMap, callExpression);
 
-    // 添加导入语句
-    if (needImportFiles.size > 0) {
+    if (needImportFiles && needImportFiles.size > 0) {
       console.log(`    [进度] 开始添加导入语句...`);
       needImportFiles.forEach((file) => {
-        injectImportStatement(file, functionImportPath);
+        injectImportStatement(file, functionImportPath, callExpression);
       });
       console.log(`    [完成] 已为${needImportFiles.size}个文件添加导入语句`);
     }
@@ -286,7 +158,6 @@ const singleTranslateAndUpdateFiles = async (
     console.log('    [取消] 已取消代码替换操作');
   }
 
-  // 生成 mds-payload.json（供 sync-to-mds 脚本使用）
   if (medusa && medusa.appName) {
     const newKeys = Object.keys(zhCN);
     generateMdsPayload({
@@ -296,7 +167,6 @@ const singleTranslateAndUpdateFiles = async (
     });
   }
 
-  // 询问是否生成medusa excel文件
   if (medusa && medusa.appName && medusa.keyMap) {
     let shouldGenExcel = skipConfirm;
     if (!skipConfirm) {
@@ -307,12 +177,8 @@ const singleTranslateAndUpdateFiles = async (
     }
     if (shouldGenExcel) {
       try {
-        const newKeys = Object.keys(zhCN); // 新增的key
-        await generateMedusaExcel({
-          localesFilePath,
-          medusa,
-          newKeys,
-        });
+        const newKeys = Object.keys(zhCN);
+        await generateMedusaExcel({ localesFilePath, medusa, newKeys });
       } catch (error) {
         console.error('    [错误] 生成medusa excel文件失败:', error.message);
       }
@@ -322,79 +188,54 @@ const singleTranslateAndUpdateFiles = async (
   }
 
   fs.removeSync(keyJsonPath);
-  console.log(`    [提示] key.json文件已删除`);
+  console.log(`    [提示] key.json临时文件已删除`);
 
   return Object.keys(zhCN).length;
 };
 
-// 修改replaceKeysInFiles函数以支持fileCodeMap
-const replaceKeysInFiles = async (path, keyMap, fileType, fileCodeMap) => {
+const replaceKeysInFiles = async (path, keyMap, fileType, fileCodeMap, callExpr) => {
   const fileTypes = fileType.split(',').map((s) => s.trim());
   const re = new RegExp(`(${fileTypes.map((ft) => ft.replace('.', '\\.')).join('|')})$`);
   const files = find.fileSync(re, path);
 
   console.log(`    [进度] 开始替换${files.length}个文件中的key...`);
 
-  // 仅当目标项目根目录存在 .prettierrc 时才尝试格式化
   const hasPrettierRc = fs.existsSync(nodePath.join(path, '.prettierrc'));
 
-  // 动态导入 Prettier 并应用项目配置（如果可用）
   const formatWithPrettier = async (text, filePath) => {
     if (!hasPrettierRc) return text;
     try {
       const prettierModule = await import('prettier');
       const prettier = prettierModule.default || prettierModule;
       const resolved = (await prettier.resolveConfig(filePath)) || {};
-      return prettier.format(text, {
-        ...resolved,
-        // 传入 filepath 以便 Prettier 自动推断 parser（ts/tsx/js/jsx）
-        filepath: filePath,
-      });
+      return prettier.format(text, { ...resolved, filepath: filePath });
     } catch (_error) {
-      // Prettier 不可用或解析失败则跳过格式化
       return text;
     }
   };
 
   for (const file of files) {
     try {
-      // 使用fileCodeMap中的代码，如果没有则读取文件
       const code = fileCodeMap.get(file) || fs.readFileSync(file, 'utf8');
-
-      // 解析文件
       const ast = parseAST(code);
-
       let hasChanges = false;
 
-      // 遍历并替换key
       traverse(ast, {
         CallExpression(path) {
-          // 检查是否是 $i18n.get 调用
-          if (
-            path.node.callee.type === 'MemberExpression' &&
-            path.node.callee.object &&
-            path.node.callee.object.name === '$i18n' &&
-            path.node.callee.property &&
-            path.node.callee.property.name === 'get'
-          ) {
+          if (isMatchingCallee(path.node, callExpr)) {
             const args = path.node.arguments;
-            // 检查第一个参数是否是对象表达式
             if (args.length > 0 && args[0].type === 'ObjectExpression') {
-              // 查找 id 属性
               const idProperty = args[0].properties.find(
                 (prop) => prop.key && prop.key.name === 'id',
               );
 
               if (idProperty && idProperty.value) {
-                // 尝试提取 key 值（支持多种格式）
                 const oldKey = extractStringValue(idProperty.value);
 
                 if (oldKey) {
                   const newKey = keyMap[oldKey];
 
-                  // 如果在 keyMap 中找到对应的新 key，进行替换
                   if (newKey && newKey !== oldKey) {
-                    // 只替换字符串字面量，其他类型保持不变
                     if (idProperty.value.type === 'StringLiteral') {
                       idProperty.value = t.stringLiteral(newKey);
                       hasChanges = true;
@@ -411,7 +252,6 @@ const replaceKeysInFiles = async (path, keyMap, fileType, fileCodeMap) => {
         },
       });
 
-      // 如果有改动，写回文件
       if (hasChanges) {
         const newCode = generateCode(ast, code);
         const formatted = await formatWithPrettier(newCode, file);
@@ -429,8 +269,8 @@ const replaceKeysInFiles = async (path, keyMap, fileType, fileCodeMap) => {
 };
 
 module.exports = {
+  ENGINES,
   processFiles,
   translateAndUpdateFiles,
-  singleTranslateAndUpdateFiles,
   replaceKeysInFiles,
 };