ai-yuca 1.5.1 → 1.5.2

package/dist/bin/cli.js

@@ -54,6 +54,8 @@ const tinify_1 = require("../src/tinify");
 const zipAnim_1 = require("../src/zipAnim");
 const pullCrowdin_1 = require("../src/pullCrowdin");
 const sharp_1 = require("../src/sharp");
+const svgFix_1 = require("../src/svgFix");
+const gKeys_1 = require("../src/gKeys");
 const program = new commander_1.Command();
 // 设置版本和描述
 program
@@ -79,12 +81,30 @@ program
     .action(async (options) => {
     await (0, sharp_1.compressImages)(options);
 });
+// 添加 svg-fix 命令
+program
+    .command('svg-fix')
+    .description('修复SVG路径并去色 (生成到 fixed 子目录)')
+    .option('-s, --source <path>', 'SVG文件目录路径 (默认为当前目录)', '.')
+    .action(async (options) => {
+    await (0, svgFix_1.svgFix)(options);
+});
+// 添加 gkeys 命令
+program
+    .command('gkeys')
+    .description('提取 pages 目录下的翻译 key 并生成 gkeys.json')
+    .requiredOption('-s, --source <path>', 'pages 文件夹路径')
+    .option('-r, --regex <regex>', '提取 Key 的正则表达式 (默认为 {#(.+?)#})')
+    .option('-o, --output <path>', '输出文件路径 (默认为 source/gkeys.json)')
+    .action(async (options) => {
+    await (0, gKeys_1.gKeys)(options);
+});
 // 添加 tinify 命令
 program
     .command('tinify')
     .description('使用 Tinify API 压缩图片 (jpg, png, webp)')
-    .requiredOption('-s, --source <path>', '资源文件夹')
-    .requiredOption('-o, --output <path>', '导出的文件夹地址')
+    .option('-s, --source <path>', '资源文件夹 (默认为当前目录)', '.')
+    .option('-o, --output <path>', '导出的文件夹地址 (默认为 source/zip)', '')
     .option('-k, --key <string>', 'Tinify API Key (如果不提供则尝试从配置文件读取)')
     .option('-c, --config <path>', '指定配置文件路径（默认为项目根目录下的vs.config.json）')
     .action(async (options) => {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ai-yuca",
-    "version": "1.5.1",
+    "version": "1.5.2",
     "description": "一个用AI生成的开发辅助工具",
     "main": "dist/src/index.js",
     "types": "dist/src/index.d.ts",
@@ -41,6 +41,7 @@
         "md5-file": "^5.0.0",
         "mime-types": "^3.0.1",
         "sharp": "^0.34.5",
+        "svgo": "^4.0.1",
         "tinify": "^1.8.2"
     },
     "devDependencies": {

package/dist/src/gKeys.d.ts

@@ -0,0 +1,2 @@
+import { GKeysCommandOptions } from './types/gKeys';
+export declare function gKeys(options: GKeysCommandOptions): Promise<void>;

package/dist/src/gKeys.js

@@ -0,0 +1,235 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gKeys = gKeys;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+async function gKeys(options) {
+    const { source, regex, config: configPath } = options;
+    if (!source) {
+        console.error('❌ 请提供源文件夹路径 (-s)');
+        return;
+    }
+    const sourceAbs = path.resolve(process.cwd(), source);
+    if (!fs.existsSync(sourceAbs)) {
+        console.error(`❌ 源路径不存在: ${sourceAbs}`);
+        return;
+    }
+    // 读取配置文件
+    const configFile = configPath || path.join(process.cwd(), 'vs.config.json');
+    if (!fs.existsSync(configFile)) {
+        console.error(`❌ 配置文件不存在: ${configFile}`);
+        return;
+    }
+    let langFilePath = '';
+    let keysDirAbs = '';
+    try {
+        const configData = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+        if (configData.crowdin && configData.crowdin.keysDir) {
+            keysDirAbs = path.resolve(process.cwd(), configData.crowdin.keysDir);
+            langFilePath = path.join(keysDirAbs, 'lang.ts');
+        }
+        else {
+            console.warn('⚠️ 配置文件中未找到 crowdin.keysDir，将跳过生成 lang.ts');
+        }
+    }
+    catch (e) {
+        console.error(`❌ 读取配置文件失败: ${e}`);
+        return;
+    }
+    // 默认正则匹配 {#...#}
+    const regexPattern = regex ? new RegExp(regex, 'g') : /\{#(.+?)#\}/g;
+    console.log(`🚀 开始扫描 Pages: ${sourceAbs}`);
+    console.log(`🔍 正则表达式: ${regexPattern}`);
+    // 1. 找到所有 .tsx 入口文件
+    const entryFiles = await (0, fast_glob_1.default)('**/*.tsx', {
+        cwd: sourceAbs,
+        absolute: true
+    });
+    if (entryFiles.length === 0) {
+        console.log('⚠️ 未找到 .tsx 入口文件');
+        return;
+    }
+    console.log(`📄 找到 ${entryFiles.length} 个页面入口文件`);
+    // 用于收集所有的 pageKey 定义，以便生成 lang.ts
+    const pageKeyDefinitions = {};
+    let processedCount = 0;
+    let skippedCount = 0;
+    for (const entryFile of entryFiles) {
+        try {
+            // 生成基于文件路径的驼峰命名 Key
+            const relativePath = path.relative(sourceAbs, entryFile);
+            const pathWithoutExt = relativePath.replace(/\.[^/.]+$/, "");
+            const camelCaseKey = pathWithoutExt.split(path.sep).map(part => {
+                const parts = part.split(/[-_]/);
+                const camelParts = parts.map(p => {
+                    if (!p)
+                        return '';
+                    if (p.startsWith('['))
+                        return p;
+                    return p.charAt(0).toUpperCase() + p.slice(1);
+                });
+                return camelParts.join('').replace(/[\[\]]/g, '');
+            }).join('');
+            const keys = new Set();
+            const processedFiles = new Set();
+            // 递归处理文件，传入 keysDirAbs 用于忽略
+            await processFile(entryFile, regexPattern, keys, processedFiles, sourceAbs, keysDirAbs);
+            if (keys.size > 0) {
+                const sortedKeys = Array.from(keys).sort();
+                // 收集结果
+                pageKeyDefinitions[camelCaseKey] = sortedKeys;
+                console.log(`  ✅ 提取到 ${keys.size} 个 Key`);
+            }
+            else {
+                console.log(`  ⚠️ 未提取到 Key`);
+                pageKeyDefinitions[camelCaseKey] = [];
+            }
+            processedCount++;
+        }
+        catch (err) {
+            console.error(`❌ 处理文件出错: ${entryFile}`, err);
+        }
+    }
+    console.log(`\n----------------------------------------`);
+    console.log(`处理完成: ${processedCount} 个, 跳过: ${skippedCount} 个 (未找到 PAGE_KEY)`);
+    // 生成 lang.ts
+    if (langFilePath && Object.keys(pageKeyDefinitions).length > 0) {
+        generateLangFile(langFilePath, pageKeyDefinitions);
+    }
+    else if (Object.keys(pageKeyDefinitions).length === 0) {
+        console.log(`⚠️ 没有提取到任何 Key，跳过生成 lang.ts`);
+    }
+}
+function generateLangFile(filePath, data) {
+    let content = '// Auto generated by ai-yuca gkeys\n\n';
+    for (const [key, keys] of Object.entries(data)) {
+        content += `export const ${key}Keys = ${JSON.stringify(keys)};\n`;
+    }
+    // 确保目录存在
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, content, 'utf8');
+    console.log(`\n🎉 已生成全局语言文件: ${filePath}`);
+}
+async function processFile(filePath, regex, keys, processedFiles, rootContext, ignoreDir // 需要忽略的目录路径 (config.crowdin.keysDir)
+) {
+    // 忽略 keysDir 目录下的文件，防止循环引用
+    if (ignoreDir && path.resolve(filePath).startsWith(ignoreDir)) {
+        return;
+    }
+    if (processedFiles.has(filePath))
+        return;
+    processedFiles.add(filePath);
+    if (!fs.existsSync(filePath))
+        return;
+    let content = fs.readFileSync(filePath, 'utf8');
+    // 不再需要剔除 PAGE_KEY 定义，因为我们不再往回写，而且正则提取的是 {#...#}，
+    // 只要 lang.ts 里的定义不包含 {#...#} 且我们忽略了 lang.ts 文件，就不会有问题。
+    // 1. 提取当前文件中的 Key
+    let match;
+    regex.lastIndex = 0;
+    while ((match = regex.exec(content)) !== null) {
+        if (match[0]) {
+            keys.add(match[0]);
+        }
+    }
+    // 2. 分析 import 引用，递归处理
+    const importRegex = /import\s+(?:(?:[\w{}\s,*]+)\s+from\s+)?['"]([^'"]+)['"]/g;
+    let importMatch;
+    while ((importMatch = importRegex.exec(content)) !== null) {
+        let importPath = importMatch[1];
+        let targetPath = '';
+        // 处理 @ 别名
+        if (importPath.startsWith('@/')) {
+            // 假设 @ 指向 src 目录
+            // 我们需要找到项目根目录下的 src
+            // rootContext 是 sourceAbs，通常是 pages 目录
+            // 假设项目结构是 root/src/pages
+            // 所以 rootContext 往上两级可能是 root？或者 rootContext 本身就在 src 下？
+            // 更稳妥的方式是查找 tsconfig.json 或 jsconfig.json 中的 paths 配置
+            // 但为了简单，我们假设 @ -> process.cwd() + /src
+            targetPath = path.join(process.cwd(), 'src', importPath.substring(2));
+        }
+        else if (importPath.startsWith('.')) {
+            // 解析相对路径
+            const currentDir = path.dirname(filePath);
+            targetPath = path.resolve(currentDir, importPath);
+        }
+        else {
+            // 忽略非相对路径 (node_modules)
+            continue;
+        }
+        // 忽略样式/图片文件
+        if (importPath.match(/\.(css|less|scss|sass|png|jpg|jpeg|gif|svg)$/))
+            continue;
+        // 尝试添加扩展名
+        const extensions = ['.tsx', '.ts', '.jsx', '.js'];
+        let resolvedPath = '';
+        // 1. 尝试直接加扩展名
+        for (const ext of extensions) {
+            if (fs.existsSync(targetPath + ext)) {
+                resolvedPath = targetPath + ext;
+                break;
+            }
+        }
+        // 2. 尝试作为目录找 index
+        if (!resolvedPath) {
+            for (const ext of extensions) {
+                const indexPath = path.join(targetPath, `index${ext}`);
+                if (fs.existsSync(indexPath)) {
+                    resolvedPath = indexPath;
+                    break;
+                }
+            }
+        }
+        // 3. 如果原本就有扩展名
+        if (!resolvedPath && fs.existsSync(targetPath)) {
+            const stat = fs.statSync(targetPath);
+            if (stat.isFile()) {
+                resolvedPath = targetPath;
+            }
+        }
+        if (resolvedPath) {
+            await processFile(resolvedPath, regex, keys, processedFiles, rootContext, ignoreDir);
+        }
+    }
+}

package/dist/src/svgFix.d.ts

@@ -0,0 +1,2 @@
+import { SvgFixCommandOptions } from './types';
+export declare function svgFix(options: SvgFixCommandOptions): Promise<void>;

package/dist/src/svgFix.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.svgFix = svgFix;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const svgo_1 = require("svgo");
+async function svgFix(options) {
+    const sourcePath = path.resolve(process.cwd(), options.source || '.');
+    const destinationPath = path.join(sourcePath, 'fixed');
+    if (!fs.existsSync(sourcePath)) {
+        console.error(`❌ 源路径不存在: ${sourcePath}`);
+        return;
+    }
+    console.log(`🚀 开始处理 SVG 文件...`);
+    console.log(`📂 源目录: ${sourcePath}`);
+    console.log(`📂 输出目录: ${destinationPath}`);
+    try {
+        // 1. 查找所有SVG文件
+        const svgFiles = await (0, fast_glob_1.default)('**/*.svg', {
+            cwd: sourcePath,
+            absolute: true,
+            ignore: ['**/fixed/**'] // 避免重复处理输出目录
+        });
+        if (svgFiles.length === 0) {
+            console.log('⚠️ 未找到 SVG 文件');
+            return;
+        }
+        console.log(`🔄 找到 ${svgFiles.length} 个 SVG 文件，开始处理...`);
+        let processedCount = 0;
+        let failedCount = 0;
+        for (const file of svgFiles) {
+            try {
+                const content = fs.readFileSync(file, 'utf8');
+                // 计算输出路径，保持原有目录结构
+                const relativePath = path.relative(sourcePath, file);
+                const outputPath = path.join(destinationPath, relativePath);
+                const outputDir = path.dirname(outputPath);
+                // 确保子目录存在
+                if (!fs.existsSync(outputDir)) {
+                    fs.mkdirSync(outputDir, { recursive: true });
+                }
+                // 使用 SVGO 进行优化和去色
+                const result = (0, svgo_1.optimize)(content, {
+                    path: file,
+                    multipass: true, // 多次遍历以获得更好效果
+                    plugins: [
+                        'preset-default', // 包含 mergePaths, convertStyleToAttrs 等默认优化
+                        'removeDimensions', // 移除 width/height，方便 CSS 控制
+                        {
+                            name: 'removeAttrs',
+                            params: {
+                                attrs: '(fill|stroke|style)' // 移除颜色相关属性
+                            }
+                        },
+                        {
+                            name: 'addAttributesToSVGElement',
+                            params: {
+                                attributes: [
+                                    { fill: 'currentColor' } // 设置默认填充色为当前字体颜色
+                                ]
+                            }
+                        }
+                    ]
+                });
+                fs.writeFileSync(outputPath, result.data, 'utf8');
+                processedCount++;
+            }
+            catch (err) {
+                console.error(`✗ 处理出错: ${path.relative(sourcePath, file)}`, err);
+                failedCount++;
+            }
+        }
+        console.log(`\n✅ 处理完成: ${processedCount} 个文件`);
+        if (failedCount > 0) {
+            console.log(`❌ 失败: ${failedCount} 个文件`);
+        }
+        console.log(`🎉 输出目录: ${destinationPath}`);
+    }
+    catch (err) {
+        console.error(`❌ 执行失败: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+}

package/dist/src/tinify.js

@@ -40,13 +40,17 @@ exports.compressImagesWithTinify = compressImagesWithTinify;
 const tinify_1 = __importDefault(require("tinify"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const chalk_1 = __importDefault(require("chalk"));
 async function compressImagesWithTinify(options) {
-    const { source, output, config, key } = options;
-    if (!source || !output) {
-        console.error(chalk_1.default.red('错误: 必须提供源文件夹路径 (-s) 和导出文件夹路径 (-o)'));
-        process.exit(1);
+    let { source, output, config, key } = options;
+    // 处理默认参数
+    if (!source) {
+        source = '.';
+    }
+    if (!output) {
+        output = path.join(source, 'zip');
     }
     let apiKey = key;
     // 如果命令行没有提供key，尝试从配置文件读取
@@ -73,6 +77,42 @@ async function compressImagesWithTinify(options) {
             console.error(chalk_1.default.red(`错误: 配置文件不存在: ${configPath}`));
             process.exit(1);
         }
+        // 如果还没找到，尝试从用户主目录下的 .yuca/.env 获取
+        if (!apiKey) {
+            try {
+                const homeDir = os.homedir();
+                const envPath = path.join(homeDir, '.yuca', '.env');
+                if (fs.existsSync(envPath)) {
+                    // console.log(chalk.gray(`尝试读取 ${envPath}...`));
+                    const envContent = fs.readFileSync(envPath, 'utf8');
+                    const lines = envContent.split('\n');
+                    for (const line of lines) {
+                        const trimmedLine = line.trim();
+                        // 跳过注释和空行
+                        if (!trimmedLine || trimmedLine.startsWith('#'))
+                            continue;
+                        // 解析 KEY=VALUE
+                        const parts = trimmedLine.split('=');
+                        if (parts.length >= 2) {
+                            const key = parts[0].trim();
+                            // 获取值部分（可能包含=号，所以重新组合）
+                            const value = parts.slice(1).join('=').trim();
+                            // 移除可能的引号
+                            const cleanValue = value.replace(/^['"]|['"]$/g, '');
+                            // 检查可能的键名: tinify, TINIFY_KEY, TINIFY_API_KEY, apiKeys.tinify
+                            if (['tinify', 'TINIFY_KEY', 'TINIFY_API_KEY', 'apiKeys.tinify'].includes(key)) {
+                                apiKey = cleanValue;
+                                // console.log(chalk.green(`成功从 ${envPath} 获取到 API Key`));
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                console.warn(chalk_1.default.yellow(`警告: 读取用户环境配置失败: ${e}`));
+            }
+        }
     }
     if (!apiKey) {
         console.error(chalk_1.default.red('错误: 未提供 API Key。请通过 -k 参数或配置文件 (apiKeys.tinify) 提供。'));
@@ -93,8 +133,12 @@ async function compressImagesWithTinify(options) {
     console.log(chalk_1.default.blue(`源目录: ${sourceAbs}`));
     console.log(chalk_1.default.blue(`导出目录: ${outputAbs}`));
     // 查找图片文件
+    // 排除输出目录，防止循环压缩
     const patterns = ['**/*.{jpg,jpeg,png,webp}'];
-    const files = await (0, fast_glob_1.default)(patterns, { cwd: sourceAbs });
+    const files = await (0, fast_glob_1.default)(patterns, {
+        cwd: sourceAbs,
+        ignore: [path.relative(sourceAbs, outputAbs) + '/**']
+    });
     if (files.length === 0) {
         console.log(chalk_1.default.yellow('未找到任何图片文件。'));
         return;

package/dist/src/transKey.js

@@ -171,55 +171,23 @@ async function transKey(options) {
             console.log(`✅ 生成 ${fileName}: 总 Key 数 ${sortedKeys.length}, 已翻译 ${matchedCount}`);
         }
         // 5. 生成未翻译词条文件 (un-trans.json)
-        // 根据需求 "un-trans.json 存放在 source 中"
         const untransPath = path.join(outputDir, 'un-trans.json');
-        let existingUntransData = {};
-        // 读取 un-trans.json 的存量数据
-        if (fs.existsSync(untransPath)) {
-            try {
-                existingUntransData = JSON.parse(fs.readFileSync(untransPath, 'utf8'));
-            }
-            catch (e) {
-                console.warn(`无法解析 un-trans.json: ${e}`);
-            }
-        }
-        // 合并新旧未翻译数据（保留旧数据）
-        // 逻辑：以新的 untranslatedKeys 为主，如果旧数据里有该语言该key且有值（虽然理论上未翻译文件里的值应该是空的，但也许用户手动填了？），
-        // 还是保留空值，因为既然在 source 里没值，说明还是未翻译。
-        // 但用户说 "每次执行这个操作前这个文件的存量数据"，意思是把新生成的未翻译数据和旧的合并？
-        // 通常 un-trans.json 只是一个报告文件。
-        // 如果用户想保留 un-trans.json 里的数据，可能是想看累计的未翻译？
-        // 但如果某个 key 在本次运行中已经翻译了（在 oldData 中有值），它就不应该出现在 un-trans.json 中了。
-        // 所以，un-trans.json 应该只包含当前真正未翻译的 key。
-        // "存量数据" 可能指的是：如果 un-trans.json 里有一些 key 是本次扫描没扫到的（比如代码删了），是否要保留？
-        // 或者，用户只是想把新发现的未翻译 key 合并进去？
-        // 根据需求 "每次执行这个操作前这个文件的存量数据" -> 可能是指读取它，然后做某种合并。
-        // 但最合理的逻辑是：un-trans.json 应该反映当前的未翻译状态。
-        // 如果 key 在代码中存在且未翻译 -> 写入 un-trans.json
-        // 如果 key 在代码中不存在 -> 不写入
-        // 如果 key 已翻译 -> 不写入
-        // 但既然提到了 "存量数据"，我将采用以下策略：
-        // 1. 读取旧 un-trans.json
-        // 2. 将本次检测到的未翻译 key 合并进去 (如果旧文件里有额外的内容，保留之？不，这会导致废弃 key 堆积)
-        // 让我们假设 "存量数据" 是指保留那些在本次扫描中依然未翻译的条目，或者仅仅是做一次全量覆盖？
-        // 如果是全量覆盖，那就不需要读取存量数据了。
-        // 既然明确要求 "每次执行这个操作前这个文件的存量数据"，那我就把旧数据读出来，
-        // 然后把本次的未翻译数据合并进去（覆盖旧的）。
-        // 修正：按照 "un-trans.json" 的通常用途，它应该是“当前未翻译词条的快照”。
-        // 但为了满足 "保留存量数据" 的字面意思，我会把旧数据 merge 进去。
-        // 比如：旧数据有 { "en": { "A": "" } }，本次扫描发现 { "en": { "B": "" } }
-        // 结果是 { "en": { "A": "", "B": "" } }
-        // 风险：如果 "A" 已经在代码中删除了，它还会留在 un-trans.json 中。
-        const finalUntransData = { ...existingUntransData };
+        let finalUntransData = {};
+        // 只需要判断文件是否存在，如果不存在则创建（实际上这里我们每次都会重新生成内容）
+        // 如果存在，我们不需要读取它的旧值来做逻辑判断，而是直接覆盖写入最新的未翻译条目
+        // 或者，如果用户的意图是保留旧的 un-trans.json 中的某些手动编辑过的值（虽然通常它是空的）？
+        // 根据最新指示 "transKey 不需要读取旧值"，我们直接忽略读取步骤。
+        // 初始化结构
         for (const lang of langMap) {
-            if (!finalUntransData[lang]) {
-                finalUntransData[lang] = {};
-            }
-            // 合并当前未翻译的
+            finalUntransData[lang] = {};
+            // 写入当前扫描到的未翻译 key
             for (const key in untranslatedKeys[lang]) {
                 finalUntransData[lang][key] = "";
             }
         }
+        // 如果文件不存在，或者即使存在，我们也覆盖它（因为不需要读取旧值）
+        // 但为了稳妥起见，如果文件不存在，我们肯定要创建。
+        // fs.writeFileSync 会自动创建文件（如果目录存在，目录在上面已经创建了）
         fs.writeFileSync(untransPath, JSON.stringify(finalUntransData, null, 2), 'utf8');
         console.log(`\n📋 未翻译词条已导出至: ${untransPath}`);
         console.log('\n所有文件生成完毕！');

package/dist/src/types/gKeys.d.ts

@@ -0,0 +1,6 @@
+export interface GKeysCommandOptions {
+    source: string;
+    regex?: string;
+    output?: string;
+    config?: string;
+}

package/dist/src/types/gKeys.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/types/index.d.ts

@@ -11,3 +11,5 @@ export * from './pullCrowdin';
 export * from './sharp';
 export * from './tinify';
 export * from './zipAnim';
+export * from './svgFix';
+export * from './gKeys';

package/dist/src/types/index.js

@@ -35,3 +35,5 @@ __exportStar(require("./sharp"), exports);
 // 导出所有tinify相关类型
 __exportStar(require("./tinify"), exports);
 __exportStar(require("./zipAnim"), exports);
+__exportStar(require("./svgFix"), exports);
+__exportStar(require("./gKeys"), exports);

package/dist/src/types/svgFix.d.ts

@@ -0,0 +1,3 @@
+export interface SvgFixCommandOptions {
+    source: string;
+}

package/dist/src/types/svgFix.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-yuca",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "description": "一个用AI生成的开发辅助工具",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -41,6 +41,7 @@
     "md5-file": "^5.0.0",
     "mime-types": "^3.0.1",
     "sharp": "^0.34.5",
+    "svgo": "^4.0.1",
     "tinify": "^1.8.2"
   },
   "devDependencies": {