vue-auto-i18n-zlp 1.0.0

package/bin/index.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+const { program } = require("commander");
+const inquirer = require("inquirer");
+const chalk = require("chalk");
+const fs = require("fs");
+const path = require("path");
+
+// 引入所有模块
+const scan = require("../lib/scan");
+const extract = require("../lib/extract");
+const translate = require("../lib/translate");
+const write = require("../lib/write");
+const buildMap = require("../lib/buildMap");
+const refactor = require("../lib/refactor");
+const fixScript = require("../lib/fixScript");
+
+// 读取 package.json 获取版本号
+const pkg = require("../package.json");
+
+program
+  .version(pkg.version)
+  .description("Nuxt 3 自动化国际化工具")
+  .option("-k, --key <type>", "DeepSeek API Key");
+
+program.parse(process.argv);
+
+const options = program.opts();
+
+async function run() {
+  console.log(chalk.blue.bold("\n🚀 启动 Auto I18n CLI \n"));
+
+  // 1. 获取 Key
+  let apiKey = options.key || process.env.DEEPSEEK_API_KEY;
+
+  if (!apiKey) {
+    // 尝试从项目根目录的 .env 读取 (兼容性)
+    if (fs.existsSync(path.join(process.cwd(), ".env"))) {
+      require("dotenv").config({ path: path.join(process.cwd(), ".env") });
+      apiKey = process.env.DEEPSEEK_API_KEY;
+    }
+  }
+
+  if (!apiKey) {
+    const answers = await inquirer.prompt([
+      {
+        type: "password",
+        name: "key",
+        message: "请输入 DeepSeek API Key:",
+        mask: "*",
+      },
+    ]);
+    apiKey = answers.key;
+  }
+
+  const userRoot = process.cwd();
+
+  try {
+    // Step 1: 扫描
+    await scan(userRoot);
+
+    // Step 2: 提取
+    await extract(userRoot);
+
+    // Step 3: 翻译
+    await translate(userRoot, apiKey);
+
+    // Step 4: 写入
+    await write(userRoot);
+
+    // Step 5: 确认重构
+    console.log("\n----------------------------------------");
+    const { confirmRefactor } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirmRefactor",
+        message: chalk.yellow(
+          "⚠️ 即将修改项目源码进行替换，建议先 Git Commit。是否继续？",
+        ),
+        default: true,
+      },
+    ]);
+
+    if (confirmRefactor) {
+      await buildMap(userRoot);
+      await refactor(userRoot);
+      await fixScript(userRoot);
+      console.log(
+        chalk.green.bold("\n✨✨ 全部流程执行完毕！国际化迁移成功！ ✨✨"),
+      );
+      console.log(chalk.gray("请手动检查 git diff 确认修改无误。"));
+    } else {
+      console.log(chalk.yellow("已取消源码修改。仅生成了语言包文件。"));
+    }
+  } catch (e) {
+    console.error(chalk.red("\n❌ 程序执行出错:"));
+    console.error(e);
+    process.exit(1);
+  }
+}
+
+run();

package/lib/buildMap.js

@@ -0,0 +1,58 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * 构建反向映射表 (zh -> key)
+ * @param {string} userRoot
+ */
+module.exports = async function buildMap(userRoot) {
+  console.log("🚀 [Step 5-1] 生成反向映射表...");
+
+  // 源文件在 locales 目录 (上一步生成的)
+  const INPUT_FILE = path.join(userRoot, "locales", "zh.json");
+  // 输出到 cache 目录
+  const OUTPUT_FILE = path.join(userRoot, ".i18n_cache", "zh_to_key_map.json");
+
+  function flattenObject(obj, prefix = "") {
+    return Object.keys(obj).reduce((acc, k) => {
+      const pre = prefix.length ? prefix + "." : "";
+      if (typeof obj[k] === "object" && obj[k] !== null) {
+        Object.assign(acc, flattenObject(obj[k], pre + k));
+      } else {
+        acc[pre + k] = obj[k];
+      }
+      return acc;
+    }, {});
+  }
+
+  if (!fs.existsSync(INPUT_FILE)) {
+    console.error(`❌ 找不到源文件: ${INPUT_FILE}`);
+    return;
+  }
+
+  try {
+    const rawData = fs.readFileSync(INPUT_FILE, "utf-8");
+    const zhData = JSON.parse(rawData);
+
+    const flatData = flattenObject(zhData);
+
+    const entries = Object.entries(flatData).map(([key, zhText]) => {
+      return { key, zh: String(zhText) };
+    });
+
+    // 按长度降序，优先匹配长词
+    entries.sort((a, b) => b.zh.length - a.zh.length);
+
+    const reverseMap = {};
+    entries.forEach((item) => {
+      reverseMap[item.zh] = item.key;
+    });
+
+    fs.writeFileSync(OUTPUT_FILE, JSON.stringify(reverseMap, null, 2), "utf-8");
+
+    console.log(`✅ 映射表生成成功 (包含 ${entries.length} 条)`);
+    console.log(`💾 缓存至: .i18n_cache/zh_to_key_map.json`);
+  } catch (error) {
+    console.error("❌ 处理失败:", error);
+  }
+};

package/lib/extract.js

@@ -0,0 +1,78 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * 提取纯中文清单
+ * @param {string} userRoot 用户执行命令的根目录
+ */
+module.exports = async function extract(userRoot) {
+  // 1. 确定路径
+  const cacheDir = path.join(userRoot, ".i18n_cache");
+  const INPUT_FILE = path.join(cacheDir, "scan_result.json");
+  const OUTPUT_FILE = path.join(cacheDir, "todo_list.json");
+
+  // 正则表达式集合
+  const REGEX_QUOTES = /(['"`])([^'"`\n\r]*[\u4e00-\u9fa5]+[^'"`\n\r]*)\1/g;
+  const REGEX_TAG_CONTENT =
+    />([^<]*[\u4e00-\u9fa5]+[^<]*)<|^\s*([\u4e00-\u9fa5]+)\s*$/gm;
+  const REGEX_COMMENT_BLOCK = /\/\*[\s\S]*?\*\//;
+  const REGEX_COMMENT_HTML = /<!--[\s\S]*?-->/;
+
+  console.log("🔍 [Step 2] 正在提取中文清单...");
+
+  try {
+    if (!fs.existsSync(INPUT_FILE)) {
+      console.error(`❌ 未找到扫描结果，请先执行扫描步骤。路径: ${INPUT_FILE}`);
+      return;
+    }
+
+    const rawData = fs.readFileSync(INPUT_FILE, "utf-8");
+    const fileList = JSON.parse(rawData);
+    let allChinese = new Set();
+
+    fileList.forEach((file) => {
+      let content = file.content;
+      if (!content) return;
+
+      // 移除块注释和HTML注释
+      content = content
+        .replace(REGEX_COMMENT_BLOCK, "")
+        .replace(REGEX_COMMENT_HTML, "");
+
+      // 移除行内注释 //
+      const lines = content.split("\n");
+      const cleanLines = lines.map((line) => {
+        if (line.trim().startsWith("//")) return "";
+        return line;
+      });
+      content = cleanLines.join("\n");
+
+      // 提取策略 1: 引号包裹
+      let match;
+      while ((match = REGEX_QUOTES.exec(content)) !== null) {
+        const text = match[2].trim();
+        if (text) allChinese.add(text);
+      }
+
+      // 提取策略 2: 标签内容
+      REGEX_TAG_CONTENT.lastIndex = 0;
+      const tagMatches = content.matchAll(REGEX_TAG_CONTENT);
+      for (const m of tagMatches) {
+        const text = (m[1] || m[2] || "").trim();
+        if (text && !text.includes("{{") && !text.includes("}}")) {
+          allChinese.add(text);
+        }
+      }
+    });
+
+    // 排序并保存
+    const sortedList = Array.from(allChinese).sort();
+    fs.writeFileSync(OUTPUT_FILE, JSON.stringify(sortedList, null, 2), "utf-8");
+
+    console.log(`✅ 提取完成！共 ${sortedList.length} 条唯一中文词条。`);
+    console.log(`💾 提取结果缓存至: .i18n_cache/todo_list.json`);
+  } catch (error) {
+    console.error("❌ 提取出错:", error);
+    throw error; // 抛出错误让主程序捕获
+  }
+};

package/lib/fixScript.js

@@ -0,0 +1,78 @@
+/*
+ * @Author: zhouliping
+ * @Date: 2026-01-20 17:36:23
+ * @LastEditors:
+ * @LastEditTime: 2026-01-20 17:49:13
+ * @Description:
+ * @FilePath: \学习\auto-i18n-cli\lib\fixScript.js
+ */
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * 修复 Nuxt 3 Script Setup 引入
+ * @param {string} userRoot
+ */
+module.exports = async function fixScript(userRoot) {
+  console.log("🚀 [Step 5-3] 修复 <script setup> 引入...");
+
+  const cacheDir = path.join(userRoot, ".i18n_cache");
+  const FILE_LIST_JSON = path.join(cacheDir, "scan_result.json"); // 使用 scan_result 以保持一致
+
+  const REGEX_SCRIPT_SETUP = /<script\s+setup[^>]*>([\s\S]*?)<\/script>/;
+  const REGEX_HAS_USE_I18N = /const\s+\{\s*[^}]*\bt\b[^}]*\}\s*=\s*useI18n\(\)/;
+
+  let files = [];
+  if (fs.existsSync(FILE_LIST_JSON)) {
+    const list = JSON.parse(fs.readFileSync(FILE_LIST_JSON, "utf-8"));
+    files = list.map((item) => item.path);
+  } else {
+    console.error("❌ 找不到 scan_result.json");
+    return;
+  }
+
+  let modifiedCount = 0;
+
+  files.forEach((filePath) => {
+    if (!fs.existsSync(filePath)) return;
+
+    let content = fs.readFileSync(filePath, "utf-8");
+    const match = content.match(REGEX_SCRIPT_SETUP);
+
+    if (match) {
+      const scriptContent = match[1];
+      // 检查是否已经引入
+      const hasImport = REGEX_HAS_USE_I18N.test(scriptContent);
+
+      if (!hasImport) {
+        const lines = scriptContent.split("\n");
+        let insertIndex = 0;
+
+        // 智能定位插入点：跳过 import 语句
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i].trim();
+          if (line.startsWith("import ")) {
+            insertIndex = i + 1;
+          } else if (line === "" && insertIndex === i) {
+            insertIndex = i + 1;
+          } else if (line !== "" && !line.startsWith("//")) {
+            break;
+          }
+        }
+
+        // 插入 useI18n
+        lines.splice(insertIndex, 0, `const { t } = useI18n()`);
+        const newScriptContent = lines.join("\n");
+
+        // 只替换 script 部分
+        const newFileContent = content.replace(scriptContent, newScriptContent);
+
+        fs.writeFileSync(filePath, newFileContent, "utf-8");
+        // console.log(`🔧 修复引用: ${path.basename(filePath)}`);
+        modifiedCount++;
+      }
+    }
+  });
+
+  console.log(`🎉 修复完成！补充了 ${modifiedCount} 个文件的 useI18n 引用。`);
+};

package/lib/refactor.js

@@ -0,0 +1,135 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 核心替换逻辑
+ * @param {string} userRoot 
+ */
+module.exports = async function refactor(userRoot) {
+    console.log('🚀 [Step 5-2] 执行代码重构 (替换中文为 Key)...');
+
+    const cacheDir = path.join(userRoot, '.i18n_cache');
+    const MAP_FILE = path.join(cacheDir, 'zh_to_key_map.json');
+    const FILE_LIST_JSON = path.join(cacheDir, 'scan_result.json'); 
+
+    // 正则表达式
+    const REGEX_ATTR = /([@:a-zA-Z0-9-]+)\s*=\s*(['"])([^'"]*?[\u4e00-\u9fa5]+[^'"]*?)\2/g;
+    const REGEX_TEXT = />([^<]*?[\u4e00-\u9fa5]+[^<]*?)</g;
+    const REGEX_STRING = /(['"`])([^'"`\n]*?[\u4e00-\u9fa5]+[^'"`\n]*?)\1/g;
+    const REGEX_SCRIPT_BLOCK = /<script[^>]*>([\s\S]*?)<\/script>/g;
+    const REGEX_STYLE_BLOCK = /<style[^>]*>([\s\S]*?)<\/style>/g;
+    const REGEX_DEFINE_PROPS = /defineProps\s*\(\s*\{[\s\S]*?\}\s*\)/g;
+    const REGEX_WITH_DEFAULTS = /withDefaults\s*\([\s\S]*?\}\s*\)/g;
+
+    if (!fs.existsSync(MAP_FILE)) {
+        console.error('❌ 找不到映射表 zh_to_key_map.json');
+        return;
+    }
+    const map = JSON.parse(fs.readFileSync(MAP_FILE, 'utf-8'));
+
+    let files = [];
+    if (fs.existsSync(FILE_LIST_JSON)) {
+        const list = JSON.parse(fs.readFileSync(FILE_LIST_JSON, 'utf-8'));
+        files = list.map(item => item.path);
+    } else {
+        console.error('❌ 找不到文件列表 scan_result.json');
+        return;
+    }
+
+    let globalReplaceCount = 0;
+
+    files.forEach(filePath => {
+        if (!fs.existsSync(filePath)) return;
+
+        let content = fs.readFileSync(filePath, 'utf-8');
+        const originalContent = content;
+
+        // 保护 <style>
+        const stylePlaceholders = [];
+        content = content.replace(REGEX_STYLE_BLOCK, (match) => {
+            const pid = `__STYLE_PLACEHOLDER_${stylePlaceholders.length}__`;
+            stylePlaceholders.push(match);
+            return pid;
+        });
+
+        // 保护 <script> 
+        const scriptPlaceholders = [];
+        content = content.replace(REGEX_SCRIPT_BLOCK, (match) => {
+            const pid = `__SCRIPT_PLACEHOLDER_${scriptPlaceholders.length}__`;
+            scriptPlaceholders.push(match);
+            return pid;
+        });
+
+        // --- Template 替换 ---
+        content = content.replace(REGEX_ATTR, (match, attr, quote, value) => {
+            const key = map[value.trim()];
+            if (key) {
+                if (attr.startsWith(':') || attr.startsWith('v-bind')) return match; 
+                return `:${attr}="$t('${key}')"`;
+            }
+            return match;
+        });
+
+        content = content.replace(REGEX_TEXT, (match, value) => {
+            const trimmed = value.trim();
+            const key = map[trimmed];
+            if (key) return match.replace(trimmed, `{{ $t('${key}') }}`);
+            return match;
+        });
+
+        content = content.replace(REGEX_STRING, (match, quote, value) => {
+            if (value.includes('__')) return match;
+            const key = map[value.trim()];
+            if (key) return `$t('${key}')`;
+            return match;
+        });
+
+        // --- Script 替换 ---
+        scriptPlaceholders.forEach((scriptContent, index) => {
+            const propsPlaceholders = []; // 这里用一个数组存所有的 props 占位符
+
+            // 保护 withDefaults
+            let safeScript = scriptContent.replace(REGEX_WITH_DEFAULTS, (match) => {
+                const pid = `__PROPS_PLACEHOLDER_${propsPlaceholders.length}__`;
+                propsPlaceholders.push(match);
+                return pid;
+            });
+
+            // 保护 defineProps
+            safeScript = safeScript.replace(REGEX_DEFINE_PROPS, (match) => {
+                const pid = `__PROPS_PLACEHOLDER_${propsPlaceholders.length}__`;
+                propsPlaceholders.push(match);
+                return pid;
+            });
+
+            // 执行 Script 内的替换 (t)
+            safeScript = safeScript.replace(REGEX_STRING, (match, quote, value) => {
+                if (value.includes('__PROPS_PLACEHOLDER')) return match;
+                const key = map[value.trim()];
+                if (key) return `t('${key}')`;
+                return match;
+            });
+
+            // 还原 Props (按索引还原)
+            safeScript = safeScript.replace(/__PROPS_PLACEHOLDER_(\d+)__/g, (match, idx) => {
+                return propsPlaceholders[parseInt(idx)];
+            });
+
+            // 还原到 content
+            content = content.replace(`__SCRIPT_PLACEHOLDER_${index}__`, () => safeScript);
+        });
+
+        // 还原 <style>
+        stylePlaceholders.forEach((styleContent, index) => {
+            content = content.replace(`__STYLE_PLACEHOLDER_${index}__`, () => styleContent);
+        });
+
+        if (content !== originalContent) {
+            fs.writeFileSync(filePath, content, 'utf-8');
+            console.log(`✅ 修改: ${path.basename(filePath)}`);
+            globalReplaceCount++;
+        }
+    });
+
+    console.log(`🎉 重构完成，修改了 ${globalReplaceCount} 个文件。`);
+};

package/lib/scan.js

@@ -0,0 +1,104 @@
+/*
+ * @Author: zhouliping
+ * @Date: 2026-01-20 17:35:24
+ * @LastEditors:
+ * @LastEditTime: 2026-01-20 17:44:33
+ * @Description:
+ * @FilePath: \学习\auto-i18n-cli\lib\scan.js
+ */
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * 扫描 Vue 文件中的中文
+ * @param {string} userRoot 用户执行命令的根目录 (process.cwd())
+ */
+module.exports = async function scan(userRoot) {
+  // 1. 确定缓存目录 (存放中间 json 文件)
+  const cacheDir = path.join(userRoot, ".i18n_cache");
+  if (!fs.existsSync(cacheDir)) {
+    fs.mkdirSync(cacheDir, { recursive: true });
+  }
+
+  // 配置项
+  const CONFIG = {
+    rootDir: userRoot, // 使用传入的用户根目录
+    outputFile: path.join(cacheDir, "scan_result.json"), // 输出到缓存目录
+    extensions: [".vue"],
+    ignoreDirs: [
+      "node_modules",
+      ".git",
+      ".nuxt",
+      ".output",
+      ".history",
+      "dist",
+      "public",
+      "assets",
+      "locales",
+      ".i18n_cache", // 忽略我们自己创建的缓存目录
+      "scripts",
+    ],
+    chineseRegex: /[\u4e00-\u9fa5]/,
+  };
+
+  /**
+   * 递归遍历目录获取文件列表
+   */
+  function getAllFiles(dirPath, arrayOfFiles) {
+    const files = fs.readdirSync(dirPath);
+    arrayOfFiles = arrayOfFiles || [];
+
+    files.forEach(function (file) {
+      const fullPath = path.join(dirPath, file);
+
+      // 如果是文件夹
+      try {
+        const stat = fs.statSync(fullPath);
+        if (stat.isDirectory()) {
+          // 检查是否忽略
+          if (!CONFIG.ignoreDirs.includes(file)) {
+            arrayOfFiles = getAllFiles(fullPath, arrayOfFiles);
+          }
+        } else {
+          // 如果是文件
+          if (CONFIG.extensions.includes(path.extname(file))) {
+            arrayOfFiles.push(fullPath);
+          }
+        }
+      } catch (err) {
+        // skip permission errors etc.
+      }
+    });
+
+    return arrayOfFiles;
+  }
+
+  console.log("🔍 [Step 1] 开始扫描项目中的 Vue 文件...");
+
+  const allVueFiles = getAllFiles(CONFIG.rootDir, []);
+  const result = [];
+  let chineseFileCount = 0;
+
+  // console.log(`📂 找到 ${allVueFiles.length} 个 Vue 文件，正在检查中文...`);
+
+  allVueFiles.forEach((filePath) => {
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      if (CONFIG.chineseRegex.test(content)) {
+        result.push({
+          path: filePath,
+          content: content,
+        });
+        chineseFileCount++;
+      }
+    } catch (err) {
+      console.error(`❌ 读取文件失败: ${filePath}`, err);
+    }
+  });
+
+  // 写入结果
+  fs.writeFileSync(CONFIG.outputFile, JSON.stringify(result, null, 2), "utf-8");
+
+  console.log(`✅ 扫描完成！共发现 ${chineseFileCount} 个包含中文的文件。`);
+  console.log(`💾 扫描结果缓存至: .i18n_cache/scan_result.json`);
+};

package/lib/translate.js

@@ -0,0 +1,140 @@
+const fs = require("fs");
+const path = require("path");
+// 注意：移除了 dotenv，因为 apiKey 由外部传入
+const fetch = require("node-fetch"); // 如果 Node 版本较低可能需要安装这个，Node 18+ 自带 fetch
+
+/**
+ * AI 翻译核心逻辑
+ * @param {string} userRoot 用户根目录
+ * @param {string} apiKey DeepSeek API Key
+ */
+module.exports = async function translate(userRoot, apiKey) {
+  // 路径配置
+  const cacheDir = path.join(userRoot, ".i18n_cache");
+  const INPUT_FILE = path.join(cacheDir, "todo_list.json");
+  const OUTPUT_FILE = path.join(cacheDir, "translation_map.json");
+
+  // API 配置
+  const BASE_URL = "https://api.deepseek.com";
+  const MODEL_NAME = "deepseek-chat";
+  const CHUNK_SIZE = 30;
+
+  console.log("🔍 [Step 3] AI 正在进行翻译 (DeepSeek)...");
+
+  if (!apiKey) {
+    throw new Error("❌ 未提供 API Key，无法进行翻译。");
+  }
+
+  if (!fs.existsSync(INPUT_FILE)) {
+    console.error("⚠️ 未找到 todo_list.json，跳过翻译步骤。");
+    return;
+  }
+
+  const allItems = JSON.parse(fs.readFileSync(INPUT_FILE, "utf-8"));
+  const total = allItems.length;
+
+  if (total === 0) {
+    console.log("ℹ️ 待翻译列表为空，跳过。");
+    return;
+  }
+
+  // 读取已有的翻译结果（如果翻译了一半断了，可以接着跑）
+  let finalMap = {};
+  if (fs.existsSync(OUTPUT_FILE)) {
+    try {
+      finalMap = JSON.parse(fs.readFileSync(OUTPUT_FILE, "utf-8"));
+    } catch (e) {}
+  }
+
+  // 过滤掉已经翻译过的（可选优化，这里暂时简单全量处理，或者根据你的逻辑调整）
+  // 简单起见，这里还是按原文逻辑跑
+
+  let successCount = 0;
+  console.log(`🚀 开始翻译，共 ${total} 条数据...`);
+
+  // 定义 AI 调用函数
+  async function callAI(list) {
+    const prompt = `
+      你是一个 i18n 专家。请将以下中文数组转换为 i18n 配置对象。
+      输入数据：${JSON.stringify(list)}
+      要求：
+      1. 为每个中文生成语义化 snake_case Key。
+      2. 提供 en 和 de 的翻译。
+      3. 只输出标准的 JSON 格式，不要 Markdown 标记。
+      4. 格式示例：
+      {
+        "中文原文": { "key": "hello_world", "zh": "中文原文", "en": "Hello", "de": "Hallo" }
+      }
+    `;
+
+    try {
+      const response = await fetch(`${BASE_URL}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+          model: MODEL_NAME,
+          messages: [
+            {
+              role: "system",
+              content: "You are a helpful assistant that outputs JSON only.",
+            },
+            { role: "user", content: prompt },
+          ],
+          response_format: { type: "json_object" },
+        }),
+      });
+
+      const data = await response.json();
+      if (data.error) throw new Error(data.error.message);
+
+      const content = data.choices[0].message.content;
+      return JSON.parse(content);
+    } catch (error) {
+      console.error("❌ API 调用失败:", error.message);
+      return null;
+    }
+  }
+
+  // 分批处理
+  for (let i = 0; i < total; i += CHUNK_SIZE) {
+    const chunk = allItems.slice(i, i + CHUNK_SIZE);
+
+    // 简单检查：如果这一批的中文都已经存在于 finalMap 中，跳过
+    const allExist = chunk.every((text) => finalMap[text]);
+    if (allExist) {
+      console.log(
+        `⏭️ 跳过第 ${i + 1} - ${Math.min(i + CHUNK_SIZE, total)} 条 (已存在)`,
+      );
+      successCount += chunk.length;
+      continue;
+    }
+
+    console.log(
+      `🔄 正在处理第 ${i + 1} - ${Math.min(i + CHUNK_SIZE, total)} 条...`,
+    );
+
+    let result = null;
+    let retries = 3;
+    while (retries > 0 && !result) {
+      result = await callAI(chunk);
+      if (!result) {
+        console.log(`⚠️ 请求失败，正在重试 (${retries}次剩余)...`);
+        retries--;
+      }
+    }
+
+    if (result) {
+      Object.assign(finalMap, result);
+      successCount += chunk.length;
+      fs.writeFileSync(OUTPUT_FILE, JSON.stringify(finalMap, null, 2), "utf-8");
+    } else {
+      console.error(`❌ 这一批数据处理失败。`);
+    }
+  }
+
+  console.log(`✅ 翻译完成: ${successCount} / ${total}`);
+  console.log(`💾 结果已保存至: .i18n_cache/translation_map.json`);
+};

package/lib/write.js

@@ -0,0 +1,100 @@
+/*
+ * @Author: zhouliping
+ * @Date: 2026-01-20 17:35:51
+ * @LastEditors:
+ * @LastEditTime: 2026-01-20 17:46:35
+ * @Description:
+ * @FilePath: \学习\auto-i18n-cli\lib\write.js
+ */
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * 将翻译结果写入 locales 文件夹
+ * @param {string} userRoot 用户根目录
+ */
+module.exports = async function write(userRoot) {
+  console.log("🔍 [Step 4] 正在生成语言包文件...");
+
+  const cacheDir = path.join(userRoot, ".i18n_cache");
+  const INPUT_MAP = path.join(cacheDir, "translation_map.json");
+  // 关键修改：生成到用户项目根目录下的 locales
+  const LOCALES_DIR = path.join(userRoot, "locales");
+
+  const FILES = {
+    zh: "zh.json",
+    en: "en.json",
+    de: "de.json",
+  };
+
+  if (!fs.existsSync(INPUT_MAP)) {
+    console.error("❌ 错误：找不到翻译结果 translation_map.json");
+    return;
+  }
+
+  const fileContent = fs.readFileSync(INPUT_MAP, "utf-8");
+  if (!fileContent.trim()) return;
+
+  let translationMap;
+  try {
+    translationMap = JSON.parse(fileContent);
+  } catch (e) {
+    console.error("❌ JSON 解析失败:", e.message);
+    return;
+  }
+
+  const isArray = Array.isArray(translationMap);
+  const items = isArray ? translationMap : Object.values(translationMap);
+
+  if (items.length === 0) {
+    console.warn("⚠️ 数据为空，跳过写入。");
+    return;
+  }
+
+  const maps = { zh: {}, en: {}, de: {} };
+  let validCount = 0;
+
+  items.forEach((item) => {
+    if (item && item.key) {
+      maps.zh[item.key] = item.zh;
+      maps.en[item.key] = item.en;
+      maps.de[item.key] = item.de;
+      validCount++;
+    }
+  });
+
+  if (!fs.existsSync(LOCALES_DIR)) {
+    fs.mkdirSync(LOCALES_DIR, { recursive: true });
+  }
+
+  Object.keys(FILES).forEach((lang) => {
+    const filePath = path.join(LOCALES_DIR, FILES[lang]);
+    const newMap = maps[lang];
+    let existingMap = {};
+
+    // 读取旧文件合并（保留旧翻译）
+    if (fs.existsSync(filePath)) {
+      try {
+        existingMap = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      } catch (e) {}
+    }
+
+    // 注意：这里采取“旧文件优先”还是“新翻译优先”取决于需求
+    // 通常这里是 merge，如果 key 相同，是用 AI 的新翻译覆盖，还是保留旧人工翻译？
+    // 这里使用：新生成的 key 会覆盖旧的，或者追加新的
+    const finalMap = { ...existingMap, ...newMap };
+
+    // 按 key 排序让文件好看点
+    const sortedMap = {};
+    Object.keys(finalMap)
+      .sort()
+      .forEach((key) => (sortedMap[key] = finalMap[key]));
+
+    fs.writeFileSync(filePath, JSON.stringify(sortedMap, null, 2), "utf-8");
+    console.log(
+      `💾 已写入: locales/${FILES[lang]} (Keys: ${Object.keys(sortedMap).length})`,
+    );
+  });
+
+  console.log("✅ 语言包生成完毕！");
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "vue-auto-i18n-zlp",
+  "version": "1.0.0",
+  "description": "Vue 自动化国际化工具",
+  "main": "bin/index.js",
+  "bin": {
+    "auto-i18n": "./bin/index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "nuxt",
+    "i18n",
+    "vue",
+    "automation"
+  ],
+  "author": "zhouliping",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^9.5.0",
+    "dotenv": "^16.4.5",
+    "inquirer": "^8.2.6",
+    "node-fetch": "^2.7.0"
+  }
+}