@playcraft/cli 0.0.53 → 0.0.56

package/project-templates/playable-template-phaser/scripts/base64-to-mp3.js

@@ -0,0 +1,340 @@
+/**
+ * Base64 音频转 MP3 文件脚本
+ *
+ * 支持两种输入源：
+ *   1. 直接传入 base64 字符串
+ *   2. 从 JS/TS 文件中提取 base64 常量
+ *
+ * 使用方法:
+ *   node scripts/base64-to-mp3.js --input=<base64字符串或文件路径> --output=<输出mp3路径>
+ *   node scripts/base64-to-mp3.js --file=./src/config/const.ts --var=Btn_Click_Audio --output=./output.mp3
+ *   node scripts/base64-to-mp3.js --help
+ *
+ * 示例:
+ *   # 从 JS 文件提取变量
+ *   node scripts/base64-to-mp3.js --file=./src/game/config/const.ts --var=Btn_Click_Audio -o click.mp3
+ *
+ *   # 直接传入 base64 字符串（适合短字符串）
+ *   node scripts/base64-to-mp3.js --input="SGVsbG8..." -o output.mp3
+ *
+ *   # 从文本文件读取 base64（适合长字符串）
+ *   node scripts/base64-to-mp3.js --input=./base64.txt -o output.mp3
+ *
+ *   # 支持 brotli 压缩的 base64（先解压再写入）
+ *   node scripts/base64-to-mp3.js --file=./src/game/config/const.ts --var=Btn_Click_Audio -o click.mp3 --brotli
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 解析命令行参数
+ */
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const config = {
+    input: null,     // base64 字符串或包含 base64 的文件路径
+    file: null,      // JS/TS 源文件路径（从中提取变量）
+    varName: null,   // 要提取的变量名
+    output: null,    // 输出 mp3 文件路径
+    brotli: false,   // 是否先进行 brotli 解压
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') {
+      showHelp();
+      process.exit(0);
+    } else if (arg.startsWith('--input=')) {
+      config.input = arg.split('=').slice(1).join('=');
+    } else if (arg === '--input' || arg === '-i') {
+      config.input = args[++i];
+    } else if (arg.startsWith('--file=')) {
+      config.file = arg.split('=').slice(1).join('=');
+    } else if (arg.startsWith('--var=')) {
+      config.varName = arg.split('=').slice(1).join('=');
+    } else if (arg.startsWith('--output=') || arg.startsWith('-o=')) {
+      config.output = arg.split('=').slice(1).join('=');
+    } else if (arg === '--output' || arg === '-o') {
+      config.output = args[++i];
+    } else if (arg === '--brotli') {
+      config.brotli = true;
+    }
+  }
+
+  return config;
+}
+
+/**
+ * 从 JS/TS 文件中提取指定变量的字符串值
+ */
+function extractVarFromFile(filePath, varName) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+
+  // 匹配多种导出/赋值格式：
+  // export const Xxx = '...'
+  // export const Xxx = "..."
+  // const Xxx = '...'
+  // const Xxx = "..."
+  // export const Xxx = `...`
+  const patterns = [
+    // 单引号
+    new RegExp(`(?:export\\s+)?(?:const|let|var)\\s+${varName}\\s*=\\s*'([^']*)'`, 's'),
+    // 双引号
+    new RegExp(`(?:export\\s+)?(?:const|let|var)\\s+${varName}\\s*=\\s*"([^"]*)"`, 's'),
+    // 模板字符串
+    new RegExp(`(?:export\\s+)?(?:const|let|var)\\s+${varName}\\s*=\\s*\`([^\`]*)\``, 's'),
+    // 带类型注解: const Xxx: string = '...'
+    new RegExp(`(?:export\\s+)?(?:const|let|var)\\s+${varName}\\s*:\\s*\\w+\\s*=\\s*'([^']*)'`, 's'),
+    new RegExp(`(?:export\\s+)?(?:const|let|var)\\s+${varName}\\s*:\\s*\\w+\\s*=\\s*"([^"]*)"`, 's'),
+  ];
+
+  for (const pattern of patterns) {
+    const match = content.match(pattern);
+    if (match) {
+      return match[1];
+    }
+  }
+
+  return null;
+}
+
+/**
+ * 获取 base64 字符串
+ */
+function getBase64String(config) {
+  // 方式 1：从 JS/TS 文件提取变量
+  if (config.file && config.varName) {
+    const absPath = path.resolve(config.file);
+    if (!fs.existsSync(absPath)) {
+      console.error(`❌ File not found: ${absPath}`);
+      process.exit(1);
+    }
+    console.log(`📄 Reading variable "${config.varName}" from: ${absPath}`);
+    const value = extractVarFromFile(absPath, config.varName);
+    if (!value) {
+      console.error(`❌ Variable "${config.varName}" not found in ${config.file}`);
+      process.exit(1);
+    }
+    console.log(`✅ Found variable, length: ${value.length} chars`);
+    return value;
+  }
+
+  // 方式 2：直接输入或从文件读取
+  if (config.input) {
+    // 判断是文件路径还是 base64 字符串
+    if (fs.existsSync(config.input)) {
+      console.log(`📄 Reading base64 from file: ${config.input}`);
+      return fs.readFileSync(config.input, 'utf-8').trim();
+    }
+    // 直接当作 base64 字符串
+    return config.input;
+  }
+
+  console.error('❌ No input specified. Use --input or --file + --var');
+  process.exit(1);
+}
+
+/**
+ * 格式化文件大小
+ */
+function formatSize(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return (bytes / Math.pow(k, i)).toFixed(2) + ' ' + sizes[i];
+}
+
+/**
+ * 显示帮助
+ */
+function showHelp() {
+  console.log(`
+🎵 Base64 音频转 MP3 文件工具
+
+使用方法:
+  node scripts/base64-to-mp3.js [选项]
+
+选项:
+  --file=<路径>         JS/TS 源文件路径
+  --var=<变量名>        要从文件中提取的变量名
+  --input=<base64>      直接传入 base64 字符串，或包含 base64 的文本文件路径
+  --output=<路径>, -o   输出 MP3 文件路径（默认: ./output.mp3）
+  --brotli              先进行 brotli 解压（适用于压缩后的 base64）
+  --help, -h            显示帮助信息
+
+示例:
+  # 从 const.ts 提取 Btn_Click_Audio 变量，转为 mp3
+  node scripts/base64-to-mp3.js --file=./src/game/config/const.ts --var=Btn_Click_Audio -o click.mp3
+
+  # brotli 压缩的 base64（先解压再写入）
+  node scripts/base64-to-mp3.js --file=./src/game/config/const.ts --var=Btn_Click_Audio -o click.mp3 --brotli
+
+  # base64 编码的 URL（自动识别并下载，如爱给网等素材站）
+  node scripts/base64-to-mp3.js --input="aHR0cHM6Ly9zMi5haWdlaS5jb20v..." -o bgm.mp3
+
+  # 从文本文件读取 base64
+  node scripts/base64-to-mp3.js --input=./audio_base64.txt -o output.mp3
+
+  # 直接传入短 base64 音频数据
+  node scripts/base64-to-mp3.js --input="AAAAIGZ0eXBpc29..." -o output.mp3
+  `);
+}
+
+/**
+ * 主函数
+ */
+async function main() {
+  const config = parseArgs();
+
+  if (!config.output) {
+    config.output = './output.mp3';
+  }
+
+  console.log('='.repeat(50));
+  console.log('🎵 Base64 → MP3 转换工具');
+  console.log('='.repeat(50));
+
+  // 获取 base64 字符串
+  const base64String = getBase64String(config);
+
+  // 去除可能的 data URI 前缀
+  let cleanBase64 = base64String;
+  const dataUriMatch = base64String.match(/^data:[^;]+;base64,(.+)/);
+  if (dataUriMatch) {
+    cleanBase64 = dataUriMatch[1];
+    console.log('📎 Stripped data URI prefix');
+  }
+
+  // 解码 base64
+  console.log(`🔄 Decoding base64 (${cleanBase64.length} chars)...`);
+  const buffer = Buffer.from(cleanBase64, 'base64');
+  const decodedStr = buffer.toString('utf-8');
+
+  // 自动识别：解码后是 URL 还是二进制音频数据
+  if (decodedStr.startsWith('http://') || decodedStr.startsWith('https://')) {
+    // base64 编码的是 URL，自动下载
+    const url = decodedStr.trim();
+    console.log(`🔗 Detected URL inside base64:`);
+    console.log(`   ${url}`);
+    console.log(`🌐 Downloading MP3...`);
+
+    await downloadFile(url, config.output);
+    return;
+  }
+
+  // 二进制音频数据
+  console.log(`   Decoded size: ${formatSize(buffer.length)}`);
+  let outputBuffer = buffer;
+
+  // brotli 解压（可选）
+  if (config.brotli) {
+    console.log('🗜️  Decompressing with brotli...');
+    try {
+      const brotli = require('brotli/decompress');
+      const decompressed = brotli(new Uint8Array(buffer));
+      if (!decompressed) {
+        console.error('❌ Brotli decompression returned null');
+        process.exit(1);
+      }
+      outputBuffer = Buffer.from(decompressed);
+      console.log(`   Decompressed size: ${formatSize(outputBuffer.length)}`);
+    } catch (e) {
+      console.error(`❌ Brotli decompression failed: ${e.message}`);
+      console.log('   Tip: npm install brotli');
+      process.exit(1);
+    }
+  }
+
+  // 写入文件
+  saveFile(config.output, outputBuffer);
+
+/**
+ * 下载文件
+ */
+function downloadFile(url, outputFilePath) {
+  return new Promise((resolve, reject) => {
+    const outputPath = path.resolve(outputFilePath);
+    const outputDir = path.dirname(outputPath);
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    // 根据协议选择 http 或 https
+    const httpModule = url.startsWith('https') ? require('https') : require('http');
+
+    const request = httpModule.get(url, (response) => {
+      // 处理重定向
+      if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        console.log(`   ↪ Redirecting to: ${response.headers.location}`);
+        return downloadFile(response.headers.location, outputFilePath).then(resolve).catch(reject);
+      }
+
+      if (response.statusCode !== 200) {
+        reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+        return;
+      }
+
+      const contentLength = response.headers['content-length'];
+      if (contentLength) {
+        console.log(`   Content-Length: ${formatSize(parseInt(contentLength))}`);
+      }
+
+      const fileStream = fs.createWriteStream(outputPath);
+      let downloadedBytes = 0;
+
+      response.on('data', (chunk) => {
+        downloadedBytes += chunk.length;
+      });
+
+      response.pipe(fileStream);
+
+      fileStream.on('finish', () => {
+        fileStream.close();
+        console.log('');
+        console.log('='.repeat(50));
+        console.log(`✅ Downloaded to: ${outputPath}`);
+        console.log(`📦 File size: ${formatSize(downloadedBytes)}`);
+        console.log('='.repeat(50));
+        resolve();
+      });
+
+      fileStream.on('error', (err) => {
+        fs.unlinkSync(outputPath);
+        reject(err);
+      });
+    });
+
+    request.on('error', reject);
+    request.setTimeout(30000, () => {
+      request.destroy();
+      reject(new Error('Download timeout (30s)'));
+    });
+  });
+}
+
+/**
+ * 保存 buffer 到文件
+ */
+function saveFile(outputFilePath, buffer) {
+  const outputPath = path.resolve(outputFilePath);
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  fs.writeFileSync(outputPath, buffer);
+
+  console.log('');
+  console.log('='.repeat(50));
+  console.log(`✅ Saved to: ${outputPath}`);
+  console.log(`📦 File size: ${formatSize(buffer.length)}`);
+  console.log('='.repeat(50));
+}
+
+// 运行
+main().catch(error => {
+  console.error('❌ Error:', error.message);
+  process.exit(1);
+});

package/project-templates/playable-template-phaser/scripts/convert-to-webp.js

@@ -0,0 +1,370 @@
+/**
+ * 图片转 WebP 格式脚本
+ * 
+ * 使用方法:
+ *   node scripts/convert-to-webp.js                           // 默认质量 100，保留原图
+ *   node scripts/convert-to-webp.js 90                        // 质量 90
+ *   node scripts/convert-to-webp.js --quality=80              // 质量 80
+ *   node scripts/convert-to-webp.js -q 90 --delete-original   // 质量 90，删除原图
+ *   node scripts/convert-to-webp.js --dry-run                 // 预览模式
+ *   node scripts/convert-to-webp.js --force                   // 强制覆盖
+ *   node scripts/convert-to-webp.js --dir=./public/images     // 指定目录
+ *   node scripts/convert-to-webp.js --help                    // 显示帮助
+ */
+
+const webp = require('webp-converter');
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+// 授予权限
+webp.grant_permission();
+
+// 默认配置
+const DEFAULT_CONFIG = {
+    dir: './src/assets',
+    quality: 100,
+    deleteOriginal: false,
+    force: false,
+    isDryRun: false
+};
+
+const SUPPORTED_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.jfif'];
+
+/**
+ * 解析命令行参数
+ */
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const config = { ...DEFAULT_CONFIG };
+
+    // 第一个参数如果是数字，视为质量值
+    if (args[0] && !args[0].startsWith('-') && !isNaN(args[0])) {
+        config.quality = parseInt(args[0]);
+    }
+
+    args.forEach((arg, index) => {
+        if (arg === '--dry-run') {
+            config.isDryRun = true;
+        } else if (arg === '--delete-original' || arg === '-d') {
+            config.deleteOriginal = true;
+        } else if (arg === '--force' || arg === '-f') {
+            config.force = true;
+        } else if (arg.startsWith('--quality=')) {
+            config.quality = parseInt(arg.split('=')[1]) || DEFAULT_CONFIG.quality;
+        } else if (arg === '-q' || arg === '--quality') {
+            const nextArg = args[index + 1];
+            if (nextArg && !isNaN(nextArg)) {
+                config.quality = parseInt(nextArg);
+            }
+        } else if (arg.startsWith('--dir=')) {
+            config.dir = arg.split('=')[1];
+        }
+    });
+
+    // 质量范围检查
+    if (config.quality < 0 || config.quality > 100) {
+        console.error('❌ 质量参数必须在 0-100 之间');
+        process.exit(1);
+    }
+
+    return config;
+}
+
+// 统计信息
+let stats = {
+    total: 0,
+    success: 0,
+    failed: 0,
+    skipped: 0,
+    deleted: 0,
+    originalSize: 0,
+    convertedSize: 0
+};
+
+/**
+ * 递归获取目录下所有图片文件
+ */
+function getAllImageFiles(dir, fileList = []) {
+    if (!fs.existsSync(dir)) {
+        return fileList;
+    }
+
+    const files = fs.readdirSync(dir);
+
+    files.forEach(file => {
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+
+        if (stat.isDirectory()) {
+            getAllImageFiles(filePath, fileList);
+        } else {
+            const ext = path.extname(file).toLowerCase();
+            if (SUPPORTED_EXTENSIONS.includes(ext)) {
+                fileList.push(filePath);
+            }
+        }
+    });
+
+    return fileList;
+}
+
+/**
+ * 格式化文件大小
+ */
+function formatSize(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return (bytes / Math.pow(k, i)).toFixed(2) + ' ' + sizes[i];
+}
+
+/**
+ * 询问用户确认
+ */
+function askConfirmation(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+    });
+}
+
+/**
+ * 转换单个图片
+ */
+async function convertImage(inputPath, config) {
+    const outputPath = inputPath.replace(/\.(png|jpg|jpeg|jfif)$/i, '.webp');
+    
+    // 如果已经是 webp 格式，跳过
+    if (inputPath.endsWith('.webp')) {
+        console.log(`⏭️  跳过: ${inputPath} (已是 WebP 格式)`);
+        stats.skipped++;
+        return;
+    }
+
+    // 如果输出文件已存在，直接覆盖
+    if (fs.existsSync(outputPath)) {
+        if (config.isDryRun) {
+            console.log(`🔍 [预览] 覆盖: ${outputPath}`);
+        } else {
+            console.log(`⚠️  覆盖: ${outputPath}`);
+        }
+    }
+
+    try {
+        const originalSize = fs.statSync(inputPath).size;
+        stats.originalSize += originalSize;
+
+        if (config.isDryRun) {
+            console.log(`🔍 [预览] ${inputPath} -> ${outputPath}`);
+            console.log(`   原始大小: ${formatSize(originalSize)}`);
+            if (config.deleteOriginal) {
+                console.log(`   ⚠️  将删除原图`);
+            }
+            stats.total++;
+            return;
+        }
+
+        console.log(`🔄 转换中: ${inputPath}`);
+        
+        // 转换图片
+        const result = await webp.cwebp(
+            inputPath,
+            outputPath,
+            `-q ${config.quality}`,
+            '-v'
+        );
+
+        if (result) {
+            const convertedSize = fs.statSync(outputPath).size;
+            stats.convertedSize += convertedSize;
+            
+            const ratio = ((1 - convertedSize / originalSize) * 100).toFixed(2);
+            const sizeChange = ratio > 0 ? '压缩' : '增加';
+            console.log(`✅ 成功: ${outputPath}`);
+            console.log(`   ${formatSize(originalSize)} -> ${formatSize(convertedSize)} (${sizeChange} ${Math.abs(ratio)}%)`);
+            
+            // 删除原图
+            if (config.deleteOriginal) {
+                try {
+                    fs.unlinkSync(inputPath);
+                    console.log(`🗑️  已删除原图: ${inputPath}`);
+                    stats.deleted++;
+                } catch (deleteError) {
+                    console.error(`❌ 删除失败: ${inputPath}`);
+                    console.error(`   错误: ${deleteError.message}`);
+                }
+            }
+            
+            stats.success++;
+        }
+    } catch (error) {
+        console.error(`❌ 失败: ${inputPath}`);
+        console.error(`   错误: ${error.message}`);
+        stats.failed++;
+    }
+
+    stats.total++;
+}
+
+/**
+ * 显示帮助信息
+ */
+function showHelp() {
+    console.log(`
+📸 图片转 WebP 格式工具
+
+使用方法:
+  node scripts/convert-to-webp.js [质量值] [选项]
+
+参数:
+  质量值                           设置转换质量 0-100 (默认: 100)
+                                  示例: node scripts/convert-to-webp.js 90
+
+选项:
+  --quality=<0-100>, -q <0-100>   设置转换质量 (默认: 100)
+  --delete-original, -d           转换后删除原图 ⚠️
+  --force, -f                     强制覆盖已存在的文件，不询问
+  --dry-run                       预览模式，不实际转换
+  --dir=<路径>                    指定源目录 (默认: ./src/assets)
+  --help, -h                      显示此帮助信息
+
+使用示例:
+  # 基础用法
+  node scripts/convert-to-webp.js                    # 质量 100
+  node scripts/convert-to-webp.js 90                 # 质量 90
+  node scripts/convert-to-webp.js --quality=80       # 质量 80
+
+  # 预览模式（推荐首次使用）
+  node scripts/convert-to-webp.js --dry-run          # 预览
+  node scripts/convert-to-webp.js 90 --dry-run       # 质量 90 预览
+
+  # 删除原图（谨慎使用）
+  node scripts/convert-to-webp.js 90 --delete-original
+  node scripts/convert-to-webp.js -q 85 -d
+
+  # 强制覆盖
+  node scripts/convert-to-webp.js --force            # 不询问直接覆盖
+  node scripts/convert-to-webp.js 80 -f -d           # 组合使用
+
+  # 指定目录
+  node scripts/convert-to-webp.js --dir=./public/images
+  node scripts/convert-to-webp.js --dir=./assets -q 90
+
+NPM 快捷命令:
+  npm run webp              # 质量 100
+  npm run webp:preview      # 预览模式
+  npm run webp:80           # 质量 80
+  npm run webp:90           # 质量 90
+
+质量推荐:
+  100   最高质量，文件较大 - 适合重要图标、UI 元素
+  90    极佳质量，推荐使用 - 适合游戏角色、场景图
+  80    优秀质量，文件较小 - 适合背景图、装饰图
+  70    良好质量，大幅压缩 - 适合缩略图、临时图片
+
+注意事项:
+  ⚠️  使用 --delete-original 前请确保备份
+  💡 首次使用建议先运行 --dry-run 预览
+  📦 支持格式: .png, .jpg, .jpeg, .jfif
+    `);
+}
+
+/**
+ * 主函数
+ */
+async function main() {
+    // 显示帮助
+    if (process.argv.includes('--help') || process.argv.includes('-h')) {
+        showHelp();
+        process.exit(0);
+    }
+
+    const config = parseArgs();
+
+    console.log('='.repeat(60));
+    console.log('📸 图片转 WebP 格式工具');
+    console.log('='.repeat(60));
+    console.log(`📁 源目录: ${config.dir}`);
+    console.log(`🎨 质量: ${config.quality}%`);
+    console.log(`🔧 模式: ${config.isDryRun ? '预览模式（不会实际转换）' : '转换模式'}`);
+    console.log(`🗑️  删除原图: ${config.deleteOriginal ? '是 ⚠️' : '否'}`);
+    console.log(`⚡ 强制覆盖: ${config.force ? '是' : '否'}`);
+    console.log('='.repeat(60));
+    console.log('');
+
+    // 检查源目录是否存在
+    if (!fs.existsSync(config.dir)) {
+        console.error(`❌ 错误: 目录 ${config.dir} 不存在`);
+        process.exit(1);
+    }
+
+    // 获取所有图片文件
+    console.log('🔍 扫描图片文件...');
+    const imageFiles = getAllImageFiles(config.dir);
+    
+    if (imageFiles.length === 0) {
+        console.log('⚠️  未找到支持的图片文件');
+        console.log(`   支持格式: ${SUPPORTED_EXTENSIONS.join(', ')}`);
+        process.exit(0);
+    }
+
+    console.log(`📝 找到 ${imageFiles.length} 个图片文件\n`);
+
+    // 如果要删除原图且不是预览模式，要求确认
+    if (config.deleteOriginal && !config.isDryRun && !config.force) {
+        console.log('⚠️  警告: 您选择了删除原图选项！');
+        const confirmed = await askConfirmation('确定要继续吗? (y/n): ');
+        if (!confirmed) {
+            console.log('❌ 已取消操作');
+            process.exit(0);
+        }
+        console.log('');
+    }
+
+    // 逐个转换
+    for (const imagePath of imageFiles) {
+        await convertImage(imagePath, config);
+        console.log('');
+    }
+
+    // 输出统计信息
+    console.log('='.repeat(60));
+    console.log('📊 转换统计');
+    console.log('='.repeat(60));
+    console.log(`总计: ${stats.total} 个文件`);
+    console.log(`成功: ${stats.success} 个`);
+    console.log(`失败: ${stats.failed} 个`);
+    console.log(`跳过: ${stats.skipped} 个`);
+    
+    if (config.deleteOriginal && !config.isDryRun) {
+        console.log(`删除: ${stats.deleted} 个原图`);
+    }
+    
+    if (!config.isDryRun && stats.success > 0) {
+        console.log('');
+        console.log(`原始总大小: ${formatSize(stats.originalSize)}`);
+        console.log(`转换后总大小: ${formatSize(stats.convertedSize)}`);
+        const totalRatio = ((1 - stats.convertedSize / stats.originalSize) * 100).toFixed(2);
+        console.log(`总体压缩率: ${totalRatio}%`);
+        console.log(`节省空间: ${formatSize(stats.originalSize - stats.convertedSize)}`);
+    }
+    
+    console.log('='.repeat(60));
+    console.log(config.isDryRun ? '🔍 预览完成！' : '✨ 转换完成！');
+    console.log('='.repeat(60));
+}
+
+// 运行
+main().catch(error => {
+    console.error('❌ 发生错误:', error);
+    process.exit(1);
+});