@agentscope-ai/i18n 0.1.2

package/lib/services/dashscopeMT.js

@@ -0,0 +1,182 @@
+const axios = require('axios');
+const fs = require('fs-extra');
+const path = require('path');
+
+// 语言映射
+const langMap = {
+  'en-us': 'English',
+  'ja-jp': 'Japanese',
+  'zh-cn': 'Chinese',
+  'zh-tw': 'Chinese',
+};
+
+// 日志工具函数
+const logMTError = (error, context) => {
+  const logDir = path.join(process.cwd(), 'logs');
+  const logFile = path.join(logDir, 'mt-translation-errors.log');
+
+  // 确保日志目录存在
+  fs.ensureDirSync(logDir);
+
+  const timestamp = new Date().toISOString();
+  const logEntry = {
+    timestamp,
+    error: {
+      message: error.message,
+      stack: error.stack,
+      ...(error.response && {
+        response: {
+          status: error.response.status,
+          statusText: error.response.statusText,
+          data: error.response.data,
+          headers: error.response.headers,
+        },
+      }),
+    },
+    context,
+  };
+
+  // 追加到日志文件
+  const logLine = JSON.stringify(logEntry, null, 2) + '\n' + '-'.repeat(80) + '\n';
+  fs.appendFileSync(logFile, logLine);
+
+  console.error(`    [日志] MT翻译错误已记录到: ${logFile}`);
+};
+
+// 调用DashScope机器翻译API进行批量翻译
+const callDashScopeMTBatch = async (prompts, targetLang, apiKey, retryCount = 3, type) => {
+  // 多条文案组合成一个请求
+  const combinedPrompt = prompts.map((text, index) => `${index + 1}. ${text}`).join('\n');
+  const instructionPrompt = `
+    请将以下${prompts.length}条中文文案翻译${type === 'key' ? '并总结为' : ''}为${type === 'key' ? '7个单词以内的' : ''}${langMap[targetLang] || targetLang}，
+    保持原有的序号格式：\n\n${combinedPrompt}
+  `;
+  const url = 'https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation';
+  const data = {
+    model: 'qwen-mt-plus',
+    input: {
+      messages: [
+        {
+          role: 'user',
+          content: instructionPrompt,
+        },
+      ],
+    },
+    parameters: {
+      translation_options: {
+        source_lang: 'auto',
+        target_lang: langMap[targetLang] || targetLang,
+      },
+    },
+  };
+
+  for (let i = 0; i < retryCount; i++) {
+    try {
+      const response = await axios.post(url, data, {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+      });
+
+      if (response.status === 200) {
+        const result = response.data?.output?.choices?.[0]?.message?.content;
+        if (result) {
+          // 解析批量翻译结果
+          const translations = parseBatchTranslationResult(result.trim(), prompts.length);
+          return translations;
+        } else {
+          throw new Error('批量翻译结果为空');
+        }
+      } else {
+        // 记录非200状态码错误
+        const error = new Error(`MT批量API返回非200状态码: ${response.status}`);
+        const context = {
+          attempt: i + 1,
+          totalAttempts: retryCount,
+          url,
+          targetLang,
+          promptsCount: prompts.length,
+          requestData: data,
+          response: {
+            status: response.status,
+            headers: response.headers,
+            data: response.data,
+          },
+          timestamp: new Date().toISOString(),
+        };
+        logMTError(error, context);
+
+        console.log(`    [请求] request_id=${response.headers['request_id']}`);
+        console.log(`    [请求] code=${response.status}`);
+        console.log(`    [请求] message=${response.data.message}`);
+
+        if (i < retryCount - 1) {
+          console.log(`    [重试] 第${i + 1}次MT批量翻译失败，3秒后重试...`);
+          await new Promise((resolve) => setTimeout(resolve, 3000));
+        }
+      }
+    } catch (error) {
+      // 记录网络错误或其他异常
+      const context = {
+        attempt: i + 1,
+        totalAttempts: retryCount,
+        url,
+        targetLang,
+        promptsCount: prompts.length,
+        requestData: data,
+        timestamp: new Date().toISOString(),
+      };
+      logMTError(error, context);
+
+      console.error(`    [错误] 调用DashScope MT批量翻译失败: ${error.message}`);
+      if (error.response) {
+        console.error(`    [错误] 响应状态: ${error.response.status}`);
+        console.error(`    [错误] 响应数据: ${JSON.stringify(error.response.data, null, 2)}`);
+      }
+
+      if (i < retryCount - 1) {
+        console.log(`    [重试] 第${i + 1}次MT批量翻译失败，3秒后重试...`);
+        await new Promise((resolve) => setTimeout(resolve, 3000));
+      }
+    }
+  }
+
+  throw new Error(`[错误] MT批量翻译${retryCount}次重试后仍然失败`);
+};
+
+// 解析批量翻译结果
+const parseBatchTranslationResult = (result, expectedCount) => {
+  const lines = result.split('\n').filter((line) => line.trim());
+  const translations = [];
+
+  for (let i = 0; i < expectedCount; i++) {
+    const expectedPrefix = `${i + 1}.`;
+    let found = false;
+
+    for (const line of lines) {
+      if (line.trim().startsWith(expectedPrefix)) {
+        const translation = line.replace(expectedPrefix, '').trim();
+        translations.push(translation);
+        found = true;
+        break;
+      }
+    }
+
+    if (!found) {
+      // 如果找不到对应序号的翻译，尝试按顺序匹配
+      if (translations.length < lines.length) {
+        const fallbackTranslation = lines[translations.length]?.replace(/^\d+\.\s*/, '').trim();
+        translations.push(fallbackTranslation || '');
+      } else {
+        translations.push(''); // 翻译失败，返回空字符串
+      }
+    }
+  }
+
+  return translations;
+};
+
+module.exports = {
+  callDashScopeMTBatch,
+};

package/lib/utils/ast-utils.js

@@ -0,0 +1,100 @@
+const t = require('@babel/types');
+
+/**
+ * 尝试从 AST 节点中提取字符串值
+ * 支持多种节点类型：StringLiteral, BinaryExpression, TemplateLiteral 等
+ */
+function extractStringValue(node) {
+  if (!node) return null;
+
+  switch (node.type) {
+    case 'StringLiteral':
+      return node.value;
+
+    case 'BinaryExpression':
+      // 处理字符串连接，如 'a' + 'b'
+      if (node.operator === '+') {
+        const left = extractStringValue(node.left);
+        const right = extractStringValue(node.right);
+        if (left !== null && right !== null) {
+          return left + right;
+        }
+      }
+      return null;
+
+    case 'TemplateLiteral':
+      // 处理模板字符串，如 `hello ${name}`
+      if (node.expressions.length === 0) {
+        // 纯模板字符串，没有插值
+        return node.quasis.map((quasi) => quasi.value.cooked).join('');
+      }
+      // 包含插值的模板字符串无法静态分析
+      return null;
+
+    case 'Identifier':
+      // 变量引用无法静态分析，但返回变量名用于识别
+      // 注意：这种情况下无法确定实际的key值
+      return `[variable:${node.name}]`;
+
+    default:
+      return null;
+  }
+}
+
+/**
+ * 检查 i18n.get 调用并提取 key
+ * @param {Object} node - CallExpression AST 节点
+ * @returns {Object|null} 返回 {id, dm} 或 null
+ */
+function extractI18nKey(node) {
+  if (
+    node.type !== 'CallExpression' ||
+    node.callee.type !== 'MemberExpression' ||
+    !node.callee.object ||
+    node.callee.object.name !== '$i18n' ||
+    !node.callee.property ||
+    node.callee.property.name !== 'get'
+  ) {
+    return null;
+  }
+
+  const args = node.arguments;
+  if (args.length === 0) {
+    return null;
+  }
+
+  // 处理对象形式：i18n.get({id: key, dm: defaultMessage})
+  if (args[0].type === 'ObjectExpression') {
+    const idProperty = args[0].properties.find((prop) => prop.key && prop.key.name === 'id');
+
+    const dmProperty = args[0].properties.find((prop) => prop.key && prop.key.name === 'dm');
+
+    if (!idProperty || !idProperty.value) {
+      return null;
+    }
+
+    const id = extractStringValue(idProperty.value);
+    const dm = dmProperty ? extractStringValue(dmProperty.value) : null;
+
+    return id ? { id, dm } : null;
+  }
+
+  // 处理直接传递key的形式：i18n.get(key)
+  else {
+    const id = extractStringValue(args[0]);
+    return id ? { id, dm: null } : null;
+  }
+}
+
+/**
+ * 增强的 checkI18nCall 函数，支持更多 key 格式
+ */
+function checkI18nCall(node) {
+  return extractI18nKey(node);
+}
+
+module.exports = {
+  extractStringValue,
+  extractI18nKey,
+  checkI18nCall,
+};

package/lib/utils/cli-utils.js

@@ -0,0 +1,19 @@
+const readline = require('readline');
+
+const askQuestion = (query) => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) =>
+    rl.question(query, (ans) => {
+      rl.close();
+      resolve(ans.toLowerCase());
+    }),
+  );
+};
+
+module.exports = {
+  askQuestion,
+};

package/lib/utils/excel-utils.js

@@ -0,0 +1,124 @@
+const XLSX = require('xlsx');
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * 生成medusa excel文件
+ * @param {Object} params 参数对象
+ * @param {string} params.localesFilePath 翻译文件目录
+ * @param {Object} params.medusa medusa配置
+ * @param {string} params.medusa.appName 应用名称
+ * @param {string} params.medusa.group 分组名称
+ * @param {Object} params.medusa.keyMap 语言映射配置
+ * @param {Array} params.newKeys 新增的翻译key列表
+ * @returns {string} 生成的excel文件路径
+ */
+const generateMedusaExcel = async (params) => {
+  const { localesFilePath, medusa, newKeys, customData } = params;
+
+  if (!medusa || !medusa.appName || !medusa.group || !medusa.keyMap) {
+    throw new Error('medusa配置不完整，需要appName、group和keyMap');
+  }
+
+  // 读取所有翻译文件
+  const translationFiles = {};
+
+  // 读取中文翻译文件
+  try {
+    translationFiles['zh-cn'] = fs.readJsonSync(path.join(localesFilePath, 'zh-cn.json'));
+  } catch (error) {
+    console.log('    [警告] 未找到zh-cn.json文件');
+    translationFiles['zh-cn'] = {};
+  }
+
+  // 根据keyMap读取其他语言文件
+  for (const [languageFile, columnName] of Object.entries(medusa.keyMap)) {
+    if (languageFile === 'zh-cn') continue; // 跳过中文，已经处理过了
+
+    try {
+      translationFiles[languageFile] = fs.readJsonSync(
+        path.join(localesFilePath, `${languageFile}.json`),
+      );
+    } catch (error) {
+      console.log(`    [警告] 未找到${languageFile}.json文件`);
+      translationFiles[languageFile] = {};
+    }
+  }
+
+  // 准备Excel数据
+  const excelData = [];
+
+  // 如果没有指定newKeys，则使用所有key
+  const keysToProcess =
+    newKeys && newKeys.length > 0
+      ? newKeys
+      : customData
+        ? Object.keys(customData)
+        : Object.keys(translationFiles['zh-cn'] || {});
+
+  for (const key of keysToProcess) {
+    const row = {
+      AppName: medusa.appName,
+      Group: medusa.group,
+      Key: key,
+    };
+
+    // 添加各语言的翻译
+    for (const [languageFile, columnName] of Object.entries(medusa.keyMap)) {
+      let translation = '';
+
+      if (customData) {
+        // 如果使用自定义数据，从customData中获取
+        translation = customData[key]?.[languageFile] || '';
+      } else {
+        // 否则从翻译文件中获取
+        translation = translationFiles[languageFile]?.[key] || '';
+      }
+
+      row[columnName] = translation;
+    }
+
+    excelData.push(row);
+  }
+
+  // 创建工作簿
+  const workbook = XLSX.utils.book_new();
+  const worksheet = XLSX.utils.json_to_sheet(excelData);
+
+  // 设置列宽
+  const columnWidths = [
+    { wch: 20 }, // AppName
+    { wch: 15 }, // Group
+    { wch: 30 }, // Key
+  ];
+
+  // 为每种语言添加列宽
+  Object.keys(medusa.keyMap).forEach(() => {
+    columnWidths.push({ wch: 25 });
+  });
+
+  worksheet['!cols'] = columnWidths;
+
+  // 将工作表添加到工作簿
+  XLSX.utils.book_append_sheet(workbook, worksheet, 'Translations');
+
+  // 生成文件名（包含完整时间戳）
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_');
+  const excelFileName = `medusa-translations-${timestamp}.xlsx`;
+  const excelFilePath = path.join(localesFilePath, excelFileName);
+
+  // 确保目录存在
+  fs.ensureDirSync(localesFilePath);
+
+  // 写入文件
+  XLSX.writeFile(workbook, excelFilePath);
+
+  console.log(`    [完成] 已生成medusa excel文件: ${excelFilePath}`);
+  console.log(`    [信息] 共包含${excelData.length}条翻译记录`);
+
+  return excelFilePath;
+};
+
+module.exports = {
+  generateMedusaExcel,
+};

package/lib/utils/file-utils.js

@@ -0,0 +1,280 @@
+const fs = require('fs-extra');
+const find = require('find');
+
+// 检查文件是否在忽略列表中
+const shouldIgnoreFile = (file, doNotTranslateFiles) => {
+  if (!doNotTranslateFiles || !doNotTranslateFiles.length) return false;
+
+  return doNotTranslateFiles.some((pattern) => {
+    if (typeof pattern === 'string') {
+      return file.includes(pattern);
+    } else if (pattern instanceof RegExp) {
+      return pattern.test(file);
+    }
+    return false;
+  });
+};
+
+// 添加导入语句到文件
+const injectImportStatement = (filePath, importPath) => {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const importStatement = `import $i18n from '${importPath}';\n`;
+
+    // 检查文件是否已经有这个导入语句
+    if (!content.includes(importStatement.trim())) {
+      // 检查文件是否已经有其他导入语句
+      const importRegex = /^import\s+.*?from\s+['"].*?['"];?\n/gm;
+      const imports = content.match(importRegex);
+
+      if (imports) {
+        // 在最后一个导入语句后添加
+        const lastImport = imports[imports.length - 1];
+        const newContent = content.replace(lastImport, `${lastImport}${importStatement}`);
+        fs.writeFileSync(filePath, newContent, 'utf8');
+      } else {
+        // 如果没有导入语句，添加到文件开头
+        fs.writeFileSync(filePath, importStatement + content, 'utf8');
+      }
+    }
+  } catch (error) {
+    console.error(`    [错误] 添加导入语句失败: ${filePath}`, error);
+    throw error;
+  }
+};
+
+/**
+ * 检查文件是否应该被忽略（基于第一行注释）
+ */
+const shouldIgnoreByComment = (filePath) => {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+
+    // 检查第一行（去除空白字符）
+    const firstLine = lines[0].trim();
+
+    // 检查是否是注释且包含 @i18n-ignore
+    if (firstLine.startsWith('//') && firstLine.includes('@i18n-ignore')) {
+      return true;
+    }
+
+    // 检查是否是块注释
+    if (firstLine.startsWith('/*') && firstLine.includes('@i18n-ignore')) {
+      return true;
+    }
+
+    // 检查是否是 JSX 注释
+    if (firstLine.startsWith('{/*') && firstLine.includes('@i18n-ignore')) {
+      return true;
+    }
+
+    return false;
+  } catch (error) {
+    // 如果读取文件失败，默认不忽略
+    console.warn(`    [警告] 无法读取文件 ${filePath} 进行注释检查:`, error.message);
+    return false;
+  }
+};
+
+/**
+ * 检查特定行是否应该被忽略（基于行注释）
+ * @param {string} filePath - 文件路径
+ * @param {number} lineNumber - 行号（从1开始）
+ * @returns {boolean} 是否应该忽略该行
+ */
+const shouldIgnoreLineByComment = (filePath, lineNumber) => {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+
+    // 检查行号是否有效
+    if (lineNumber < 1 || lineNumber > lines.length) {
+      return false;
+    }
+
+    const line = lines[lineNumber - 1]; // 数组索引从0开始
+    const trimmedLine = line.trim();
+
+    // 检查是否是单行注释且包含 @i18n-ignore-line
+    if (trimmedLine.startsWith('//') && trimmedLine.includes('@i18n-ignore-line')) {
+      return true;
+    }
+
+    // 检查是否是块注释且包含 @i18n-ignore-line
+    if (trimmedLine.startsWith('/*') && trimmedLine.includes('@i18n-ignore-line')) {
+      return true;
+    }
+
+    // 检查是否是 JSX 注释且包含 @i18n-ignore-line
+    if (trimmedLine.startsWith('{/*') && trimmedLine.includes('@i18n-ignore-line')) {
+      return true;
+    }
+
+    // 检查同一行是否包含注释中的 @i18n-ignore-line（可能在代码后面）
+    if (line.includes('@i18n-ignore-line')) {
+      // 检查是否在注释中
+      const commentIndex = line.indexOf('@i18n-ignore-line');
+      const beforeComment = line.substring(0, commentIndex).trim();
+      if (
+        beforeComment.includes('//') ||
+        beforeComment.includes('/*') ||
+        beforeComment.includes('{/*')
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  } catch (error) {
+    // 如果读取文件失败，默认不忽略
+    console.warn(`    [警告] 无法读取文件 ${filePath} 进行行注释检查:`, error.message);
+    return false;
+  }
+};
+
+/**
+ * 检查特定行是否在忽略块中（基于块注释）
+ * @param {string} filePath - 文件路径
+ * @param {number} lineNumber - 行号（从1开始）
+ * @returns {boolean} 是否应该忽略该行
+ */
+const shouldIgnoreBlockByComment = (filePath, lineNumber) => {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+
+    // 检查行号是否有效
+    if (lineNumber < 1 || lineNumber > lines.length) {
+      return false;
+    }
+
+    // 查找所有的 @i18n-ignore-block-start 和 @i18n-ignore-block-end 标记
+    const blockStarts = [];
+    const blockEnds = [];
+
+    lines.forEach((line, index) => {
+      const lineNum = index + 1;
+      const trimmedLine = line.trim();
+
+      // 检查是否是注释中的 @i18n-ignore-block-start
+      if (
+        (trimmedLine.startsWith('//') ||
+          trimmedLine.startsWith('/*') ||
+          trimmedLine.startsWith('{/*')) &&
+        line.includes('@i18n-ignore-block-start')
+      ) {
+        blockStarts.push(lineNum);
+      }
+
+      // 检查是否是注释中的 @i18n-ignore-block-end
+      if (
+        (trimmedLine.startsWith('//') ||
+          trimmedLine.startsWith('/*') ||
+          trimmedLine.startsWith('{/*')) &&
+        line.includes('@i18n-ignore-block-end')
+      ) {
+        blockEnds.push(lineNum);
+      }
+
+      // 检查同一行是否包含注释中的标记（可能在代码后面）
+      if (line.includes('@i18n-ignore-block-start')) {
+        // 检查是否在注释中
+        const commentIndex = line.indexOf('@i18n-ignore-block-start');
+        const beforeComment = line.substring(0, commentIndex).trim();
+        if (
+          beforeComment.includes('//') ||
+          beforeComment.includes('/*') ||
+          beforeComment.includes('{/*')
+        ) {
+          blockStarts.push(lineNum);
+        }
+      }
+
+      if (line.includes('@i18n-ignore-block-end')) {
+        // 检查是否在注释中
+        const commentIndex = line.indexOf('@i18n-ignore-block-end');
+        const beforeComment = line.substring(0, commentIndex).trim();
+        if (
+          beforeComment.includes('//') ||
+          beforeComment.includes('/*') ||
+          beforeComment.includes('{/*')
+        ) {
+          blockEnds.push(lineNum);
+        }
+      }
+    });
+
+    // 检查当前行是否在任何忽略块中
+    for (let i = 0; i < blockStarts.length; i++) {
+      const startLine = blockStarts[i];
+      // 找到对应的end标记（最近的end）
+      let endLine = null;
+      for (let j = 0; j < blockEnds.length; j++) {
+        if (blockEnds[j] > startLine) {
+          endLine = blockEnds[j];
+          break;
+        }
+      }
+
+      // 如果找到了对应的end标记，检查当前行是否在这个范围内
+      if (endLine && lineNumber >= startLine && lineNumber <= endLine) {
+        return true;
+      }
+    }
+
+    return false;
+  } catch (error) {
+    // 如果读取文件失败，默认不忽略
+    console.warn(`    [警告] 无法读取文件 ${filePath} 进行块注释检查:`, error.message);
+    return false;
+  }
+};
+
+/**
+ * 文件扫描，过滤不需要翻译白名单的文件，选取符合fileType类型的文件
+ */
+const scanFiles = (path, fileType, doNotTranslateFiles = []) => {
+  try {
+    const fileTypes = fileType.split(',').map((s) => s.trim());
+    const re = new RegExp(`(${fileTypes.map((ft) => ft.replace('.', '\\.')).join('|')})$`);
+    const files = find.fileSync(re, path);
+
+    // 过滤掉在忽略列表中的文件
+    let filteredFiles = files.filter((file) => !shouldIgnoreFile(file, doNotTranslateFiles));
+
+    // 过滤掉有 @i18n-ignore 注释的文件
+    const ignoredByComment = [];
+    filteredFiles = filteredFiles.filter((file) => {
+      if (shouldIgnoreByComment(file)) {
+        ignoredByComment.push(file);
+        return false;
+      }
+      return true;
+    });
+
+    if (ignoredByComment.length > 0) {
+      console.log(`    # 发现 ${ignoredByComment.length} 个文件包含 @i18n-ignore 注释，已跳过:`);
+      ignoredByComment.forEach((file) => {
+        console.log(`    #   - ${file}`);
+      });
+    }
+
+    console.log(
+      `    # 过滤不需翻译白名单后，找到符合${fileType}类型的文件：${filteredFiles.length}个`,
+    );
+
+    return filteredFiles;
+  } catch (error) {
+    console.error('    [错误] 文件扫描失败:', error);
+    throw error;
+  }
+};
+
+module.exports = {
+  shouldIgnoreFile,
+  injectImportStatement,
+  scanFiles,
+  shouldIgnoreLineByComment,
+  shouldIgnoreBlockByComment,
+};