pabal-resource-mcp 1.5.4 → 1.5.6

package/dist/bin/mcp-server.js

@@ -3432,62 +3432,42 @@ import { GoogleGenAI } from "@google/genai";
 import fs10 from "fs";
 import path10 from "path";
 import sharp from "sharp";
-var LANGUAGE_NAMES = {
-  "en-US": "English (US)",
-  "en-GB": "English (UK)",
-  "en-AU": "English (Australia)",
-  "en-CA": "English (Canada)",
-  "ko-KR": "Korean",
-  "ja-JP": "Japanese",
-  "zh-Hans": "Simplified Chinese",
-  "zh-Hant": "Traditional Chinese",
-  "zh-CN": "Simplified Chinese",
-  "zh-TW": "Traditional Chinese",
-  "fr-FR": "French",
-  "fr-CA": "French (Canada)",
+var GEMINI_ASPECT_RATIOS = {
+  "1:1": { ratio: 1 / 1, width: 2048, height: 2048 },
+  "2:3": { ratio: 2 / 3, width: 1696, height: 2528 },
+  "3:2": { ratio: 3 / 2, width: 2528, height: 1696 },
+  "3:4": { ratio: 3 / 4, width: 1792, height: 2400 },
+  "4:3": { ratio: 4 / 3, width: 2400, height: 1792 },
+  "4:5": { ratio: 4 / 5, width: 1856, height: 2304 },
+  "5:4": { ratio: 5 / 4, width: 2304, height: 1856 },
+  "9:16": { ratio: 9 / 16, width: 1536, height: 2752 },
+  "16:9": { ratio: 16 / 9, width: 2752, height: 1536 },
+  "21:9": { ratio: 21 / 9, width: 1584, height: 672 }
+};
+var DEVICE_ASPECT_RATIOS = {
+  phone: "9:16",
+  tablet: "3:4"
+};
+var GEMINI_LANGUAGE_NAMES = {
+  "en-US": "English",
+  "ar-EG": "Arabic",
   "de-DE": "German",
-  "es-ES": "Spanish (Spain)",
-  "es-419": "Spanish (Latin America)",
-  "es-MX": "Spanish (Mexico)",
-  "pt-BR": "Portuguese (Brazil)",
-  "pt-PT": "Portuguese (Portugal)",
+  "es-MX": "Spanish",
+  "fr-FR": "French",
+  "hi-IN": "Hindi",
+  "id-ID": "Indonesian",
   "it-IT": "Italian",
-  "nl-NL": "Dutch",
+  "ja-JP": "Japanese",
+  "ko-KR": "Korean",
+  "pt-BR": "Portuguese",
   "ru-RU": "Russian",
-  "ar": "Arabic",
-  "ar-SA": "Arabic",
-  "hi-IN": "Hindi",
-  "th-TH": "Thai",
+  "ua-UA": "Ukrainian",
   "vi-VN": "Vietnamese",
-  "id-ID": "Indonesian",
-  "ms-MY": "Malay",
-  "tr-TR": "Turkish",
-  "pl-PL": "Polish",
-  "uk-UA": "Ukrainian",
-  "cs-CZ": "Czech",
-  "el-GR": "Greek",
-  "ro-RO": "Romanian",
-  "hu-HU": "Hungarian",
-  "sv-SE": "Swedish",
-  "da-DK": "Danish",
-  "fi-FI": "Finnish",
-  "no-NO": "Norwegian",
-  "he-IL": "Hebrew",
-  "sk-SK": "Slovak",
-  "bg-BG": "Bulgarian",
-  "hr-HR": "Croatian",
-  "ca-ES": "Catalan"
+  "zh-CN": "Chinese"
 };
 function getLanguageName(locale) {
-  if (LANGUAGE_NAMES[locale]) {
-    return LANGUAGE_NAMES[locale];
-  }
-  const baseCode = locale.split("-")[0];
-  const matchingKey = Object.keys(LANGUAGE_NAMES).find(
-    (key) => key.startsWith(baseCode + "-") || key === baseCode
-  );
-  if (matchingKey) {
-    return LANGUAGE_NAMES[matchingKey];
+  if (locale in GEMINI_LANGUAGE_NAMES) {
+    return GEMINI_LANGUAGE_NAMES[locale];
   }
   return locale;
 }
@@ -3507,29 +3487,15 @@ function readImageAsBase64(imagePath) {
   }
   return { data: base64, mimeType };
 }
-async function getImageDimensions(imagePath) {
-  const metadata = await sharp(imagePath).metadata();
-  return {
-    width: metadata.width || 1080,
-    height: metadata.height || 1920
-  };
+function getAspectRatioForDevice(deviceType) {
+  return DEVICE_ASPECT_RATIOS[deviceType];
 }
-function calculateAspectRatio(width, height) {
-  const ratio = width / height;
-  if (Math.abs(ratio - 1) < 0.1) return "1:1";
-  if (Math.abs(ratio - 9 / 16) < 0.1) return "9:16";
-  if (Math.abs(ratio - 16 / 9) < 0.1) return "16:9";
-  if (Math.abs(ratio - 3 / 4) < 0.1) return "3:4";
-  if (Math.abs(ratio - 4 / 3) < 0.1) return "4:3";
-  return ratio < 1 ? "9:16" : "16:9";
-}
-async function translateImage(sourcePath, sourceLocale, targetLocale, outputPath, preserveWords) {
+async function translateImage(sourcePath, sourceLocale, targetLocale, outputPaths, deviceType, preserveWords) {
   try {
     const client = getGeminiClient();
     const sourceLanguage = getLanguageName(sourceLocale);
     const targetLanguage = getLanguageName(targetLocale);
-    const { width, height } = await getImageDimensions(sourcePath);
-    const aspectRatio = calculateAspectRatio(width, height);
+    const aspectRatio = getAspectRatioForDevice(deviceType);
     const { data: imageData, mimeType } = readImageAsBase64(sourcePath);
     const preserveInstruction = preserveWords && preserveWords.length > 0 ? `
 - Do NOT translate these words, keep them exactly as-is: ${preserveWords.join(", ")}` : "";
@@ -3583,14 +3549,17 @@ IMPORTANT INSTRUCTIONS:
     for (const part of parts) {
       if (part.inlineData?.data) {
         const imageBuffer = Buffer.from(part.inlineData.data, "base64");
-        const outputDir = path10.dirname(outputPath);
-        if (!fs10.existsSync(outputDir)) {
-          fs10.mkdirSync(outputDir, { recursive: true });
+        for (const outputPath of outputPaths) {
+          const outputDir = path10.dirname(outputPath);
+          if (!fs10.existsSync(outputDir)) {
+            fs10.mkdirSync(outputDir, { recursive: true });
+          }
+          await sharp(imageBuffer).png().toFile(outputPath);
         }
-        await sharp(imageBuffer).png().toFile(outputPath);
         return {
           success: true,
-          outputPath
+          outputPath: outputPaths[0]
+          // Return primary path
         };
       }
     }
@@ -3628,7 +3597,8 @@ async function translateImagesWithProgress(translations, onProgress, preserveWor
       translation.sourcePath,
       translation.sourceLocale,
       translation.targetLocale,
-      translation.outputPath,
+      translation.outputPaths,
+      translation.deviceType,
       preserveWords
     );
     if (result.success) {
@@ -3649,10 +3619,85 @@ async function translateImagesWithProgress(translations, onProgress, preserveWor
   return { successful, failed, errors };
 }
 
+// src/tools/aso/utils/localize-screenshots/locale-mapping.constants.ts
+var GEMINI_LOCALE_GROUPS = {
+  // English - covers all English variants
+  "en-US": ["en-US", "en-AU", "en-CA", "en-GB", "en-IN", "en-SG", "en-ZA"],
+  // Arabic - Gemini ar-EG → Unified ar
+  "ar-EG": ["ar"],
+  // German
+  "de-DE": ["de-DE"],
+  // Spanish - covers Latin America, Spain, and US Spanish
+  "es-MX": ["es-419", "es-ES", "es-US"],
+  // French - covers France and Canada
+  "fr-FR": ["fr-FR", "fr-CA"],
+  // Hindi
+  "hi-IN": ["hi-IN"],
+  // Indonesian
+  "id-ID": ["id-ID"],
+  // Italian
+  "it-IT": ["it-IT"],
+  // Japanese
+  "ja-JP": ["ja-JP"],
+  // Korean
+  "ko-KR": ["ko-KR"],
+  // Portuguese - covers Brazil and Portugal
+  "pt-BR": ["pt-BR", "pt-PT"],
+  // Russian
+  "ru-RU": ["ru-RU"],
+  // Ukrainian - Gemini ua-UA → Unified uk-UA
+  "ua-UA": ["uk-UA"],
+  // Vietnamese
+  "vi-VN": ["vi-VN"],
+  // Chinese - covers Simplified, Traditional, and Hong Kong
+  "zh-CN": ["zh-Hans", "zh-Hant", "zh-HK"]
+};
+function getGeminiLocale(unifiedLocale) {
+  for (const [geminiLocale, unifiedLocales] of Object.entries(
+    GEMINI_LOCALE_GROUPS
+  )) {
+    if (unifiedLocales.includes(unifiedLocale)) {
+      return geminiLocale;
+    }
+  }
+  return null;
+}
+function prepareLocalesForTranslation(locales, primaryLocale) {
+  const targetLocales = locales.filter((l) => l !== primaryLocale);
+  const localeMapping = /* @__PURE__ */ new Map();
+  const geminiLocalesNeeded = /* @__PURE__ */ new Set();
+  const skippedLocales = [];
+  for (const locale of targetLocales) {
+    const geminiLocale = getGeminiLocale(locale);
+    if (geminiLocale === null) {
+      skippedLocales.push(locale);
+      continue;
+    }
+    geminiLocalesNeeded.add(geminiLocale);
+    const existing = localeMapping.get(geminiLocale) || [];
+    if (!existing.includes(locale)) {
+      existing.push(locale);
+    }
+    localeMapping.set(geminiLocale, existing);
+  }
+  const groupedLocales = [];
+  for (const [, unifiedLocales] of localeMapping) {
+    if (unifiedLocales.length > 1) {
+      groupedLocales.push(...unifiedLocales.slice(1));
+    }
+  }
+  return {
+    translatableLocales: Array.from(geminiLocalesNeeded),
+    localeMapping,
+    skippedLocales,
+    groupedLocales
+  };
+}
+
 // src/tools/aso/utils/localize-screenshots/image-resizer.util.ts
 import sharp2 from "sharp";
 import fs11 from "fs";
-async function getImageDimensions2(imagePath) {
+async function getImageDimensions(imagePath) {
   const metadata = await sharp2(imagePath).metadata();
   if (!metadata.width || !metadata.height) {
     throw new Error(`Unable to read dimensions from ${imagePath}`);
@@ -3723,14 +3768,16 @@ async function resizeImage(inputPath, outputPath, targetDimensions) {
     // Preserve aspect ratio
     withoutEnlargement: false,
     // Allow enlargement if needed
-    background: bgColor
+    background: bgColor,
     // Use detected edge color
+    kernel: "lanczos3"
+    // High-quality downscaling algorithm
   }).flatten({ background: bgColor }).png().toFile(outputPath + ".tmp");
   fs11.renameSync(outputPath + ".tmp", outputPath);
 }
 async function validateAndResizeImage(sourcePath, translatedPath) {
-  const sourceDimensions = await getImageDimensions2(sourcePath);
-  const translatedDimensions = await getImageDimensions2(translatedPath);
+  const sourceDimensions = await getImageDimensions(sourcePath);
+  const translatedDimensions = await getImageDimensions(translatedPath);
   const needsResize = sourceDimensions.width !== translatedDimensions.width || sourceDimensions.height !== translatedDimensions.height;
   if (needsResize) {
     await resizeImage(translatedPath, translatedPath, sourceDimensions);
@@ -3857,7 +3904,7 @@ function getSupportedLocales(slug) {
   };
 }
 function getTargetLocales(allLocales, primaryLocale, requestedTargets) {
-  let targets = allLocales.filter((locale) => locale !== primaryLocale);
+  let localesToProcess = allLocales;
   if (requestedTargets && requestedTargets.length > 0) {
     const validTargets = requestedTargets.filter((t) => allLocales.includes(t));
     const invalidTargets = requestedTargets.filter(
@@ -3865,32 +3912,50 @@ function getTargetLocales(allLocales, primaryLocale, requestedTargets) {
     );
     if (invalidTargets.length > 0) {
       console.warn(
-        `Warning: Some requested locales are not supported: ${invalidTargets.join(", ")}`
+        `Warning: Some requested locales are not in product: ${invalidTargets.join(", ")}`
       );
     }
-    targets = validTargets.filter((t) => t !== primaryLocale);
+    localesToProcess = validTargets;
   }
-  return targets;
+  const {
+    translatableLocales,
+    localeMapping,
+    skippedLocales,
+    groupedLocales
+  } = prepareLocalesForTranslation(localesToProcess, primaryLocale);
+  return {
+    targets: translatableLocales,
+    skippedLocales,
+    groupedLocales,
+    localeMapping
+  };
 }
-function buildTranslationTasks(slug, screenshots, primaryLocale, targetLocales, skipExisting) {
+function buildTranslationTasks(slug, screenshots, primaryLocale, targetLocales, localeMapping, skipExisting) {
   const tasks = [];
   const screenshotsDir = getScreenshotsDir(slug);
   for (const targetLocale of targetLocales) {
+    const outputLocales = localeMapping.get(targetLocale) || [];
     for (const screenshot of screenshots) {
-      const outputPath = path11.join(
-        screenshotsDir,
-        targetLocale,
-        screenshot.type,
-        screenshot.filename
-      );
-      if (skipExisting && fs12.existsSync(outputPath)) {
+      const outputPaths = [];
+      for (const locale of outputLocales) {
+        const outputPath = path11.join(
+          screenshotsDir,
+          locale,
+          screenshot.type,
+          screenshot.filename
+        );
+        if (!skipExisting || !fs12.existsSync(outputPath)) {
+          outputPaths.push(outputPath);
+        }
+      }
+      if (outputPaths.length === 0) {
         continue;
       }
       tasks.push({
         sourcePath: screenshot.fullPath,
         sourceLocale: primaryLocale,
         targetLocale,
-        outputPath,
+        outputPaths,
         deviceType: screenshot.type,
         filename: screenshot.filename
       });
@@ -3941,22 +4006,34 @@ async function handleLocalizeScreenshots(input) {
       ]
     };
   }
-  const targetLocales = getTargetLocales(
-    allLocales,
-    primaryLocale,
-    requestedTargetLocales
-  );
+  const {
+    targets: targetLocales,
+    skippedLocales,
+    groupedLocales,
+    localeMapping
+  } = getTargetLocales(allLocales, primaryLocale, requestedTargetLocales);
   if (targetLocales.length === 0) {
+    const skippedMsg = skippedLocales.length > 0 ? ` (Skipped due to Gemini limitation: ${skippedLocales.join(", ")})` : "";
     return {
       content: [
         {
           type: "text",
-          text: `\u274C No target locales to translate to. Primary locale: ${primaryLocale}, Available: ${allLocales.join(", ")}`
+          text: `\u274C No target locales to translate to. Primary locale: ${primaryLocale}, Available: ${allLocales.join(", ")}${skippedMsg}`
         }
       ]
     };
   }
-  results.push(`\u{1F3AF} Target locales: ${targetLocales.join(", ")}`);
+  results.push(`\u{1F3AF} Target locales to translate: ${targetLocales.join(", ")}`);
+  if (groupedLocales.length > 0) {
+    results.push(
+      `\u{1F4CB} Grouped locales (saved together): ${groupedLocales.join(", ")}`
+    );
+  }
+  if (skippedLocales.length > 0) {
+    results.push(
+      `\u26A0\uFE0F Skipped locales (not supported by Gemini): ${skippedLocales.join(", ")}`
+    );
+  }
   const sourceScreenshots = scanLocaleScreenshots(appInfo.slug, primaryLocale);
   let filteredScreenshots = sourceScreenshots.filter(
     (s) => deviceTypes.includes(s.type)
@@ -4013,6 +4090,7 @@ ${screenshotsDir2}/${primaryLocale}/tablet/1.png, 2.png, ...`
     filteredScreenshots,
     primaryLocale,
     targetLocales,
+    localeMapping,
     skipExisting
   );
   if (tasks.length === 0) {
@@ -4041,8 +4119,11 @@ ${screenshotsDir2}/${primaryLocale}/tablet/1.png, 2.png, ...`
       tasksByLocale[task.targetLocale].push(task);
     }
     for (const [locale, localeTasks] of Object.entries(tasksByLocale)) {
+      const grouped = localeMapping.get(locale) || [];
+      const groupedOthers = grouped.filter((l) => l !== locale);
+      const groupInfo = groupedOthers.length > 0 ? ` \u2192 also: ${groupedOthers.join(", ")}` : "";
       results.push(`
-\u{1F4C1} ${locale}:`);
+\u{1F4C1} ${locale}${groupInfo}:`);
       for (const task of localeTasks) {
         results.push(`   - ${task.deviceType}/${task.filename}`);
       }
@@ -4098,11 +4179,17 @@ ${screenshotsDir2}/${primaryLocale}/tablet/1.png, 2.png, ...`
   if (translationResult.successful > 0) {
     results.push(`
 \u{1F50D} Validating image dimensions...`);
-    const successfulTasks = tasks.filter((t) => fs12.existsSync(t.outputPath));
-    const resizePairs = successfulTasks.map((t) => ({
-      sourcePath: t.sourcePath,
-      translatedPath: t.outputPath
-    }));
+    const resizePairs = [];
+    for (const task of tasks) {
+      for (const outputPath of task.outputPaths) {
+        if (fs12.existsSync(outputPath)) {
+          resizePairs.push({
+            sourcePath: task.sourcePath,
+            translatedPath: outputPath
+          });
+        }
+      }
+    }
     const resizeResult = await batchValidateAndResize(resizePairs);
     if (resizeResult.resized > 0) {
       results.push(`   \u{1F527} Resized ${resizeResult.resized} images to match source dimensions`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pabal-resource-mcp",
-  "version": "1.5.4",
+  "version": "1.5.6",
   "type": "module",
   "description": "MCP server for ASO data management with shared types and utilities",
   "author": "skyu",