@agentscope-ai/i18n 0.1.2

package/lib/i18n.ts

@@ -0,0 +1,134 @@
+// Interface for translation variables
+interface I18nVariables {
+  [key: string]: any;
+}
+
+// Interface for multi-language mapping
+interface IMultiLangMap {
+  [key: string]: { [key: string]: string };
+}
+
+// Supported language types
+type TLanguage = 'en' | 'zh' | string;
+
+type I18nOptions = {
+  id: string;
+  dm: string;
+} | string;
+
+/**
+ * Internationalization (i18n) utility class
+ * Handles language management and string translations
+ */
+class I18N {
+  multiLangMap: IMultiLangMap;
+  language: TLanguage;
+  private translations: Record<string, string> = {};
+
+  /**
+   * Initialize I18N instance with multi-language map
+   * @param config Configuration object containing multiLangMap
+   */
+  constructor({ multiLangMap }: { multiLangMap: IMultiLangMap }) {
+    this.multiLangMap = multiLangMap;
+    this.language = localStorage.getItem('data-prefers-language') || 'en';
+  }
+
+  /**
+   * Convert value to string with fallback
+   * @param value Input value to convert
+   * @param defaultValue Fallback value if conversion fails
+   * @returns String representation of the value
+   */
+  toString = (value: any, defaultValue: string) => {
+    if (value === undefined || value === null) {
+      return defaultValue;
+    }
+
+    if (typeof value === 'string') {
+      return value;
+    }
+
+    if (value?.toString && typeof value.toString === 'function') {
+      return value.toString();
+    }
+
+    return value || defaultValue;
+  };
+
+  /**
+   * Set current application language
+   * @param language Language code to set ('en' or 'zh')
+   */
+  setCurrentLanguage(language: TLanguage) {
+    localStorage.setItem('data-prefers-language', language);
+    this.language = language;
+  }
+
+  /**
+   * Get current application language
+   * @returns Current language code
+   */
+  getCurrentLanguage() {
+    return this.language;
+  }
+
+  /**
+   * Format translation string with variables
+   * @param idObj Translation ID or object containing ID and default message
+   * @param variables Variables to interpolate into the translation
+   * @returns Formatted translation string
+   */
+  format = (
+    idObj: string | { id: string; dm: string },
+    variables: I18nVariables,
+  ) => {
+    const { multiLangMap, language } = this;
+    const langMap = multiLangMap[language] || {};
+    let template = '';
+
+    if (typeof idObj === 'string') {
+      template = langMap[idObj as keyof typeof langMap] || idObj;
+    } else {
+      const { id, dm } = idObj;
+      template = langMap[id as keyof typeof langMap] || dm || id;
+    }
+
+    return template.replace(/\{(\w+)\}/g, (_match: string, key: string) =>
+      this.toString(variables[key], _match),
+    );
+  };
+
+  /**
+   * Get translation for given ID
+   * @param id Translation ID or object containing ID and default message
+   * @param variables Optional variables to interpolate
+   * @returns Translated string
+   */
+  get(options: I18nOptions, variables?: I18nVariables): string {
+    const { id, dm } = options;
+    let message = this.translations[id] || dm;
+
+    if (variables) {
+      Object.entries(variables).forEach(([key, value]) => {
+        message = message.replace(new RegExp(`{${key}}`, 'g'), String(value));
+      });
+    }
+
+    return message;
+  }
+
+  setTranslations(translations: Record<string, string>): void {
+    this.translations = translations;
+  }
+}
+
+import enLangMap from '../locales/en-us.json';
+import cnLangMap from '../locales/zh-cn.json';
+
+const multiLangMap = {
+  zh: cnLangMap,
+  en: enLangMap,
+};
+
+export default new I18N({ multiLangMap });

package/lib/index.js

@@ -0,0 +1,12 @@
+const { init, initMT, patch, patchMT, check, reverse } = require('./core/translator');
+const { run: medusaRun } = require('./utils/medusa');
+
+module.exports = {
+  init,
+  initMT,
+  patch,
+  patchMT,
+  check,
+  reverse,
+  medusaRun,
+};

package/lib/parse-jsx.js

@@ -0,0 +1,380 @@
+const babylon = require('@babel/parser');
+const traverse = require('@babel/traverse').default;
+const generate = require('@babel/generator').default;
+const t = require('@babel/types');
+const fs = require('fs-extra');
+const { shouldIgnoreLineByComment, shouldIgnoreBlockByComment } = require('./utils/file-utils');
+
+// 中文识别正则表达式
+const chnRegExp = new RegExp(/[^\x00-\xff]/);
+
+// 检查是否只包含中文标点符号
+const onlyContainsChinesePunctuation = (text) => {
+  // 中文标点符号正则，包括全角标点符号和常见符号
+  const chinesePunctuationRegex =
+    /[，。！？；：""''（）【】《》｜、…—·~～@#$%^&*()_+\-={}\[\]|\\:;"'<>,.?\/]/g;
+  // 移除所有中文标点符号
+  const textWithoutPunctuation = text.replace(chinesePunctuationRegex, '');
+  // 如果移除标点后为空，说明只包含标点符号
+  return textWithoutPunctuation.trim() === '';
+};
+
+const onlyContainsEmoji = (text) => {
+  // Emoji 正则表达式，包含常见的emoji Unicode范围
+  const emojiRegex =
+    /[\u{1F600}-\u{1F64F}]|[\u{1F300}-\u{1F5FF}]|[\u{1F680}-\u{1F6FF}]|[\u{1F1E0}-\u{1F1FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]|[\u{1F900}-\u{1F9FF}]|[\u{1F018}-\u{1F270}]|[\u{238C}-\u{2454}]|[\u{20D0}-\u{20FF}]|[\u{FE00}-\u{FE0F}]|[\u{1F200}-\u{1F2FF}]|[\u{1F700}-\u{1F77F}]|[\u{1F780}-\u{1F7FF}]|[\u{1F800}-\u{1F8FF}]|[\u{2300}-\u{23FF}]|[\u{2B00}-\u{2BFF}]|[\u{3030}]|[\u{303D}]|[\u{3297}]|[\u{3299}]/gu;
+
+  // 移除所有空白字符
+  const trimmedText = text.trim();
+
+  // 如果文本为空，返回false
+  if (!trimmedText) {
+    return false;
+  }
+
+  // 移除所有emoji字符
+  const textWithoutEmoji = trimmedText.replace(emojiRegex, '');
+
+  // 如果移除emoji后为空，说明只包含emoji
+  return textWithoutEmoji === '';
+};
+
+// 检查节点是否是i18n调用
+function isI18nCall(node) {
+  return (
+    node &&
+    node.type === 'CallExpression' &&
+    node.callee &&
+    node.callee.type === 'MemberExpression' &&
+    node.callee.object &&
+    node.callee.object.name === '$i18n' &&
+    node.callee.property &&
+    node.callee.property.name === 'get'
+  );
+}
+
+// 检测是否在 console 方法中
+function isInConsoleCall(path) {
+  const consoleMethods = [
+    'log',
+    'warn',
+    'error',
+    'info',
+    'debug',
+    'trace',
+    'group',
+    'groupEnd',
+    'groupCollapsed',
+    'assert',
+    'table',
+    'time',
+    'timeEnd',
+    'count',
+    'countReset',
+  ];
+
+  return path.findParent((p) => {
+    return (
+      p.isCallExpression() &&
+      p.node.callee &&
+      p.node.callee.type === 'MemberExpression' &&
+      p.node.callee.object &&
+      p.node.callee.object.name === 'console' &&
+      p.node.callee.property &&
+      consoleMethods.includes(p.node.callee.property.name)
+    );
+  });
+}
+
+// 生成i18n调用节点
+const createI18nCallNode = (i18nKey, defaultMessage, variables = []) => {
+  const baseNode = t.callExpression(
+    t.memberExpression(t.identifier('$i18n'), t.identifier('get')),
+    [
+      t.objectExpression([
+        t.objectProperty(t.identifier('id'), t.stringLiteral(i18nKey)),
+        t.objectProperty(t.identifier('dm'), t.stringLiteral(defaultMessage)),
+      ]),
+    ],
+  );
+
+  if (variables.length > 0) {
+    baseNode.arguments.push(t.objectExpression(variables));
+  }
+
+  return baseNode;
+};
+
+// 处理复杂表达式，生成代码字符串
+const processExpression = (exp) => {
+  try {
+    const generatedCode = generate(exp, {
+      compact: true,
+      jsescOption: { minimal: true },
+    }).code;
+    return generatedCode.replace(/;$/, '');
+  } catch (error) {
+    console.error('    [错误] 处理表达式时出错:', error);
+    return '';
+  }
+};
+
+// 处理模板字符串，提取变量和生成i18n调用
+const processTemplateLiteral = (path, getOrCreateKey) => {
+  const val = [];
+  const expressions = [];
+
+  // 收集模板字符串的静态部分
+  path.node.quasis.forEach((i) => {
+    if (i.value.raw) {
+      val.push(i.value.raw);
+    }
+  });
+
+  // 处理表达式部分
+  path.node.expressions.forEach((exp) => {
+    expressions.push(processExpression(exp));
+  });
+
+  const joinedVal = val.join('');
+  if (
+    !chnRegExp.test(joinedVal) ||
+    onlyContainsChinesePunctuation(joinedVal) ||
+    onlyContainsEmoji(joinedVal)
+  ) {
+    return null;
+  }
+
+  let key = '';
+  let defaultMessage = '';
+  let variables = new Map();
+
+  // 构建key和defaultMessage，同时收集变量
+  path.node.quasis.forEach((quasi, index) => {
+    const rawValue = quasi.value.raw.replace(/^['"]|['"]$/g, '');
+    const trimmedValue = rawValue.replace(/^\s+|\s+$/g, '');
+    key += trimmedValue;
+    defaultMessage += trimmedValue;
+
+    if (index < expressions.length) {
+      const expr = expressions[index];
+      if (expr) {
+        const varName = `var${index + 1}`;
+        key += `{${varName}}`;
+        defaultMessage += `{${varName}}`;
+        variables.set(varName, expr);
+      }
+    }
+  });
+
+  const i18nKey = getOrCreateKey(key);
+
+  // 将变量转换为AST节点
+  const varProperties = Array.from(variables.entries()).map(([name, expr]) => {
+    const ast = babylon.parse(`(${expr})`);
+    const exprNode = ast.program.body[0].expression;
+    return t.objectProperty(t.identifier(name), exprNode);
+  });
+
+  return createI18nCallNode(i18nKey, defaultMessage, varProperties);
+};
+
+// 解析JSX文件，提取中文文案并生成i18n调用
+const parseJSX = (filePath, params = {}) => {
+  const i18n = {};
+  const contentKeyMap = new Map();
+  let uniqueCounter = 0;
+  let ignoredLineCount = 0; // 记录被忽略的行数
+
+  if (!params.keyPrefix) {
+    throw new Error('keyPrefix is required in params');
+  }
+
+  let code = fs.readFileSync(filePath, {
+    encoding: 'utf8',
+  });
+
+  // 生成文件路径key
+  let filePathKey = filePath.split('src/')[1] || filePath;
+  filePathKey = filePathKey.replace(/\.(tsx|jsx|js|ts)$/, '');
+  filePathKey = filePathKey.replace(/\//g, '.');
+
+  console.log(`    [解析] 开始解析文件: ${filePath}`);
+
+  // 获取或创建i18n key
+  const getOrCreateKey = (content) => {
+    if (contentKeyMap.has(content)) {
+      return contentKeyMap.get(content);
+    }
+    uniqueCounter++;
+    const i18nKey = `${params.keyPrefix}.${filePathKey}.${uniqueCounter}`;
+    contentKeyMap.set(content, i18nKey);
+    i18n[i18nKey] = content;
+    return i18nKey;
+  };
+
+  // 检查节点是否应该被忽略
+  const shouldIgnoreNode = (path) => {
+    if (!path.node.loc) {
+      return false;
+    }
+
+    const lineNumber = path.node.loc.start.line;
+
+    // 检查行级别忽略
+    const lineIgnored = shouldIgnoreLineByComment(filePath, lineNumber);
+    if (lineIgnored) {
+      ignoredLineCount++;
+      return true;
+    }
+
+    // 检查块级别忽略
+    const blockIgnored = shouldIgnoreBlockByComment(filePath, lineNumber);
+    if (blockIgnored) {
+      ignoredLineCount++;
+      return true;
+    }
+
+    return false;
+  };
+
+  // 解析文件AST
+  const ast = babylon.parse(code, {
+    sourceType: 'module',
+    allowImportExportEverywhere: true,
+    plugins: [
+      'tsx',
+      'ts',
+      'js',
+      'jsx',
+      'typescript',
+      'functionBind',
+      'objectRestSpread',
+      'classProperties',
+      'transform-decorators',
+      'decorators-legacy',
+    ],
+  });
+
+  let hasChanges = false;
+
+  // 遍历AST，处理不同类型的节点
+  traverse(ast, {
+    StringLiteral(path) {
+      const { value } = path.node;
+      if (
+        chnRegExp.test(value) &&
+        !isI18nCall(path.parent) &&
+        !path.findParent((p) => isI18nCall(p.node)) &&
+        !isInConsoleCall(path) &&
+        !shouldIgnoreNode(path)
+      ) {
+        if (onlyContainsChinesePunctuation(value) || onlyContainsEmoji(value)) {
+          return;
+        }
+        try {
+          const rawValue = (path.node.extra?.raw || JSON.stringify(value)).replace(
+            /^['"]|['"]$/g,
+            '',
+          );
+          const trimmedValue = rawValue.replace(/^\s+|\s+$/g, '');
+
+          const i18nKey = getOrCreateKey(trimmedValue);
+          const i18nCallExpression = createI18nCallNode(i18nKey, trimmedValue);
+
+          const parentType = path.parent.type;
+          if (parentType === 'JSXAttribute') {
+            path.replaceWith(t.jsxExpressionContainer(i18nCallExpression));
+          } else {
+            path.replaceWith(i18nCallExpression);
+          }
+
+          hasChanges = true;
+          path.skip();
+        } catch (e) {
+          console.error('    [错误] 处理StringLiteral时出错:', e);
+          console.error('    [错误] 节点:', path.node);
+          console.error('    [错误] 父节点:', path.parent);
+        }
+      }
+    },
+    TemplateLiteral(path) {
+      if (
+        !isI18nCall(path.parent) &&
+        !path.findParent((p) => isI18nCall(p.node)) &&
+        !isInConsoleCall(path) &&
+        !shouldIgnoreNode(path)
+      ) {
+        const newNode = processTemplateLiteral(path, getOrCreateKey);
+        if (newNode) {
+          path.replaceWith(newNode);
+          hasChanges = true;
+          path.skip();
+        }
+      }
+    },
+    JSXText(path) {
+      const { value } = path.node;
+      if (
+        chnRegExp.test(value) &&
+        !isI18nCall(path.parent) &&
+        !path.findParent((p) => isI18nCall(p.node)) &&
+        !isInConsoleCall(path) &&
+        !shouldIgnoreNode(path)
+      ) {
+        if (onlyContainsChinesePunctuation(value) || onlyContainsEmoji(value)) {
+          return;
+        }
+        const rawValue = (path.node.extra?.raw || JSON.stringify(value)).replace(
+          /^['"]|['"]$/g,
+          '',
+        );
+        const trimmedValue = rawValue.replace(/^\s+|\s+$/g, '');
+
+        const i18nKey = getOrCreateKey(trimmedValue);
+        const newNode = t.jsxExpressionContainer(createI18nCallNode(i18nKey, trimmedValue));
+
+        path.replaceWith(newNode);
+        hasChanges = true;
+        path.skip();
+      }
+    },
+  });
+
+  return new Promise((resolve) => {
+    if (Object.keys(i18n).length === 0) {
+      console.log(`    [提示] 文件 ${filePath} 中没有找到需要提取的文案`);
+      if (ignoredLineCount > 0) {
+        console.log(
+          `    [提示] 文件 ${filePath} 中有 ${ignoredLineCount} 行包含 @i18n-ignore-line 注释，已跳过`,
+        );
+      }
+      return resolve({ i18n, newCode: null });
+    }
+
+    let message = `    [完成] 从文件 ${filePath} 中提取到${Object.keys(i18n).length}条文案`;
+    if (ignoredLineCount > 0) {
+      message += `，跳过${ignoredLineCount}行包含 @i18n-ignore-line 注释的内容`;
+    }
+    console.log(message);
+
+    const newCode = hasChanges
+      ? generate(
+          ast,
+          {
+            jsescOption: {
+              minimal: true,
+              quotes: 'single',
+            },
+            retainLines: true,
+            compact: false,
+          },
+          code,
+        ).code
+      : null;
+
+    resolve({ i18n, newCode });
+  });
+};
+
+module.exports = parseJSX;

package/lib/services/dashscope.js

@@ -0,0 +1,118 @@
+const axios = require('axios');
+const fs = require('fs-extra');
+const path = require('path');
+
+// 日志工具函数
+const logApiError = (error, context) => {
+  const logDir = path.join(process.cwd(), 'logs');
+  const logFile = path.join(logDir, 'api-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(`    [日志] API错误已记录到: ${logFile}`);
+};
+
+// 调用DashScope API进行翻译
+const callDashScope = async (fileContent, tokenName, appId, apiKey, retryCount = 3) => {
+  const url = `https://dashscope.aliyuncs.com/api/v1/apps/${appId}/completion`;
+  const data = {
+    input: {
+      prompt: fileContent,
+      tokenName,
+    },
+  };
+
+  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) {
+        return response.data.output.text;
+      } else {
+        // 记录非200状态码错误
+        const error = new Error(`API返回非200状态码: ${response.status}`);
+        const context = {
+          attempt: i + 1,
+          totalAttempts: retryCount,
+          url,
+          appId,
+          tokenName,
+          requestData: data,
+          response: {
+            status: response.status,
+            headers: response.headers,
+            data: response.data,
+          },
+          timestamp: new Date().toISOString(),
+        };
+        logApiError(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}次请求失败，10秒后重试...`);
+          await new Promise((resolve) => setTimeout(resolve, 10000));
+        }
+      }
+    } catch (error) {
+      // 记录网络错误或其他异常
+      const context = {
+        attempt: i + 1,
+        totalAttempts: retryCount,
+        url,
+        appId,
+        tokenName,
+        requestData: data,
+        timestamp: new Date().toISOString(),
+      };
+      logApiError(error, context);
+
+      console.error(`    [错误] 调用DashScope失败: ${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}次请求失败，10秒后重试...`);
+        await new Promise((resolve) => setTimeout(resolve, 10000));
+      }
+    }
+  }
+
+  throw new Error(`[错误] ${retryCount}次重试后仍然失败`);
+};
+
+module.exports = {
+  callDashScope,
+};