pabal-resource-mcp 1.5.0 → 1.5.1

package/dist/bin/mcp-server.js

@@ -3,6 +3,7 @@ import {
   DEFAULT_APP_SLUG
 } from "../chunk-DLCIXAUB.js";
 import {
+  getGeminiApiKey,
   getKeywordResearchDir,
   getProductsDir,
   getPublicDir,
@@ -10,7 +11,7 @@ import {
   getPushDataDir,
   loadAsoFromConfig,
   saveAsoToAsoDir
-} from "../chunk-W62HB2ZL.js";
+} from "../chunk-YKUBCCJA.js";
 import {
   DEFAULT_LOCALE,
   appStoreToUnified,
@@ -3384,25 +3385,626 @@ Context around ${pos}: ${context}`
   };
 }
 
-// src/tools/apps/init.ts
-import fs9 from "fs";
-import path9 from "path";
+// src/tools/aso/localize-screenshots.ts
 import { z as z7 } from "zod";
 import { zodToJsonSchema as zodToJsonSchema7 } from "zod-to-json-schema";
+import fs12 from "fs";
+import path11 from "path";
+
+// src/tools/aso/utils/localize-screenshots/scan-screenshots.util.ts
+import fs9 from "fs";
+import path9 from "path";
+function getScreenshotsDir(slug) {
+  const productsDir = getProductsDir();
+  return path9.join(productsDir, slug, "screenshots");
+}
+function scanLocaleScreenshots(slug, locale) {
+  const screenshotsDir = getScreenshotsDir(slug);
+  const localeDir = path9.join(screenshotsDir, locale);
+  if (!fs9.existsSync(localeDir)) {
+    return [];
+  }
+  const screenshots = [];
+  const deviceTypes = ["phone", "tablet"];
+  for (const deviceType of deviceTypes) {
+    const deviceDir = path9.join(localeDir, deviceType);
+    if (!fs9.existsSync(deviceDir)) {
+      continue;
+    }
+    const files = fs9.readdirSync(deviceDir).filter((file) => /\.(png|jpg|jpeg|webp)$/i.test(file)).sort((a, b) => {
+      const numA = parseInt(a.match(/\d+/)?.[0] || "0");
+      const numB = parseInt(b.match(/\d+/)?.[0] || "0");
+      return numA - numB;
+    });
+    for (const filename of files) {
+      screenshots.push({
+        type: deviceType,
+        filename,
+        fullPath: path9.join(deviceDir, filename)
+      });
+    }
+  }
+  return screenshots;
+}
+
+// src/tools/aso/utils/localize-screenshots/gemini-image-translator.util.ts
+import { GoogleGenAI, Modality } from "@google/genai";
+import fs10 from "fs";
+import path10 from "path";
+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)",
+  "de-DE": "German",
+  "es-ES": "Spanish (Spain)",
+  "es-419": "Spanish (Latin America)",
+  "es-MX": "Spanish (Mexico)",
+  "pt-BR": "Portuguese (Brazil)",
+  "pt-PT": "Portuguese (Portugal)",
+  "it-IT": "Italian",
+  "nl-NL": "Dutch",
+  "ru-RU": "Russian",
+  "ar": "Arabic",
+  "ar-SA": "Arabic",
+  "hi-IN": "Hindi",
+  "th-TH": "Thai",
+  "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"
+};
+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];
+  }
+  return locale;
+}
+function getGeminiClient() {
+  const apiKey = getGeminiApiKey();
+  return new GoogleGenAI({ apiKey });
+}
+function readImageAsBase64(imagePath) {
+  const buffer = fs10.readFileSync(imagePath);
+  const base64 = buffer.toString("base64");
+  const ext = path10.extname(imagePath).toLowerCase();
+  let mimeType = "image/png";
+  if (ext === ".jpg" || ext === ".jpeg") {
+    mimeType = "image/jpeg";
+  } else if (ext === ".webp") {
+    mimeType = "image/webp";
+  }
+  return { data: base64, mimeType };
+}
+async function translateImage(sourcePath, sourceLocale, targetLocale, outputPath) {
+  try {
+    const client = getGeminiClient();
+    const sourceLanguage = getLanguageName(sourceLocale);
+    const targetLanguage = getLanguageName(targetLocale);
+    const { data: imageData, mimeType } = readImageAsBase64(sourcePath);
+    const prompt = `This is an app screenshot with text in ${sourceLanguage}.
+Please translate ONLY the text/words in this image to ${targetLanguage}.
+
+IMPORTANT INSTRUCTIONS:
+- Keep the EXACT same layout, design, colors, and visual elements
+- Only translate the visible text content to ${targetLanguage}
+- Maintain the same font style and text positioning as much as possible
+- Do NOT add any new elements or remove existing design elements
+- The output should look identical except the text language is ${targetLanguage}
+- Preserve all icons, images, and graphical elements exactly as they are`;
+    const response = await client.models.generateContent({
+      model: "imagen-3.0-generate-002",
+      contents: [
+        {
+          role: "user",
+          parts: [
+            { text: prompt },
+            {
+              inlineData: {
+                mimeType,
+                data: imageData
+              }
+            }
+          ]
+        }
+      ],
+      config: {
+        responseModalities: [Modality.TEXT, Modality.IMAGE]
+      }
+    });
+    const candidates = response.candidates;
+    if (!candidates || candidates.length === 0) {
+      return {
+        success: false,
+        error: "No response from Gemini API"
+      };
+    }
+    const parts = candidates[0].content?.parts;
+    if (!parts) {
+      return {
+        success: false,
+        error: "No content parts in response"
+      };
+    }
+    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 });
+        }
+        fs10.writeFileSync(outputPath, imageBuffer);
+        return {
+          success: true,
+          outputPath
+        };
+      }
+    }
+    return {
+      success: false,
+      error: "No image data in Gemini response"
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: message
+    };
+  }
+}
+async function translateImagesWithProgress(translations, onProgress) {
+  let successful = 0;
+  let failed = 0;
+  const errors = [];
+  for (const translation of translations) {
+    const progress = {
+      sourceLocale: translation.sourceLocale,
+      targetLocale: translation.targetLocale,
+      deviceType: translation.deviceType,
+      filename: translation.filename,
+      status: "translating"
+    };
+    onProgress?.(progress);
+    const result = await translateImage(
+      translation.sourcePath,
+      translation.sourceLocale,
+      translation.targetLocale,
+      translation.outputPath
+    );
+    if (result.success) {
+      successful++;
+      progress.status = "completed";
+    } else {
+      failed++;
+      progress.status = "failed";
+      progress.error = result.error;
+      errors.push({ path: translation.sourcePath, error: result.error || "Unknown error" });
+    }
+    onProgress?.(progress);
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  return { successful, failed, errors };
+}
+
+// src/tools/aso/utils/localize-screenshots/image-resizer.util.ts
+import sharp from "sharp";
+import fs11 from "fs";
+async function getImageDimensions(imagePath) {
+  const metadata = await sharp(imagePath).metadata();
+  if (!metadata.width || !metadata.height) {
+    throw new Error(`Unable to read dimensions from ${imagePath}`);
+  }
+  return {
+    width: metadata.width,
+    height: metadata.height
+  };
+}
+async function resizeImage(inputPath, outputPath, targetDimensions) {
+  await sharp(inputPath).resize(targetDimensions.width, targetDimensions.height, {
+    fit: "fill",
+    // Exact resize to target dimensions
+    withoutEnlargement: false
+    // Allow enlargement if needed
+  }).toFile(outputPath + ".tmp");
+  fs11.renameSync(outputPath + ".tmp", outputPath);
+}
+async function validateAndResizeImage(sourcePath, 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);
+  }
+  return {
+    resized: needsResize,
+    sourceDimensions,
+    translatedDimensions,
+    finalDimensions: sourceDimensions
+  };
+}
+async function batchValidateAndResize(pairs) {
+  let resizedCount = 0;
+  const errors = [];
+  for (const { sourcePath, translatedPath } of pairs) {
+    try {
+      if (!fs11.existsSync(translatedPath)) {
+        continue;
+      }
+      const result = await validateAndResizeImage(sourcePath, translatedPath);
+      if (result.resized) {
+        resizedCount++;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push({ path: translatedPath, error: message });
+    }
+  }
+  return {
+    total: pairs.length,
+    resized: resizedCount,
+    errors
+  };
+}
+
+// src/tools/aso/localize-screenshots.ts
+var TOOL_NAME3 = "localize-screenshots";
+var localizeScreenshotsInputSchema = z7.object({
+  appName: z7.string().describe(
+    "App name, slug, bundleId, or packageName to search for. Will be validated using search-app."
+  ),
+  targetLocales: z7.array(z7.string()).optional().describe(
+    "Specific target locales to translate to. If not provided, all supported locales from the product will be used."
+  ),
+  deviceTypes: z7.array(z7.enum(["phone", "tablet"])).optional().default(["phone", "tablet"]).describe("Device types to process (default: both phone and tablet)"),
+  dryRun: z7.boolean().optional().default(false).describe("Preview mode - shows what would be translated without actually translating"),
+  skipExisting: z7.boolean().optional().default(true).describe("Skip translation if target file already exists (default: true)")
+});
+var jsonSchema7 = zodToJsonSchema7(localizeScreenshotsInputSchema, {
+  name: "LocalizeScreenshotsInput",
+  $refStrategy: "none"
+});
+var inputSchema7 = jsonSchema7.definitions?.LocalizeScreenshotsInput || jsonSchema7;
+var localizeScreenshotsTool = {
+  name: TOOL_NAME3,
+  description: `Translate app screenshots to multiple languages using Gemini API.
+
+**IMPORTANT:** This tool uses the search-app tool internally to validate the app. You can provide an approximate name, bundleId, or packageName.
+
+This tool:
+1. Validates the app exists in registered-apps.json
+2. Reads supported locales from public/products/{slug}/locales/ directory
+3. Scans screenshots from the primary locale's screenshots folder
+4. Uses Gemini API (imagen-3.0-generate-002) to translate text in images
+5. Validates output image dimensions match source and resizes if needed
+
+**Requirements:**
+- GEMINI_API_KEY or GOOGLE_API_KEY environment variable must be set
+- Screenshots must be in: public/products/{slug}/screenshots/{locale}/phone/ and /tablet/
+- Locale files must exist in: public/products/{slug}/locales/
+
+**Example structure:**
+\`\`\`
+public/products/my-app/
+\u251C\u2500\u2500 config.json
+\u251C\u2500\u2500 locales/
+\u2502   \u251C\u2500\u2500 en-US.json (primary)
+\u2502   \u251C\u2500\u2500 ko-KR.json
+\u2502   \u2514\u2500\u2500 ja-JP.json
+\u2514\u2500\u2500 screenshots/
+    \u2514\u2500\u2500 en-US/
+        \u251C\u2500\u2500 phone/
+        \u2502   \u251C\u2500\u2500 1.png
+        \u2502   \u2514\u2500\u2500 2.png
+        \u2514\u2500\u2500 tablet/
+            \u2514\u2500\u2500 1.png
+\`\`\``,
+  inputSchema: inputSchema7
+};
+function validateApp(appName) {
+  const { app } = findRegisteredApp(appName);
+  if (!app) {
+    throw new Error(
+      `App not found: "${appName}". Use search-app tool to find the correct app name.`
+    );
+  }
+  return {
+    slug: app.slug,
+    name: app.name || app.slug
+  };
+}
+function getSupportedLocales(slug) {
+  const { config, locales } = loadProductLocales(slug);
+  const allLocales = Object.keys(locales);
+  if (allLocales.length === 0) {
+    throw new Error(`No locale files found for ${slug}`);
+  }
+  const primaryLocale = resolvePrimaryLocale(config, locales);
+  return {
+    primaryLocale,
+    allLocales
+  };
+}
+function getTargetLocales(allLocales, primaryLocale, requestedTargets) {
+  let targets = allLocales.filter((locale) => locale !== primaryLocale);
+  if (requestedTargets && requestedTargets.length > 0) {
+    const validTargets = requestedTargets.filter((t) => allLocales.includes(t));
+    const invalidTargets = requestedTargets.filter(
+      (t) => !allLocales.includes(t)
+    );
+    if (invalidTargets.length > 0) {
+      console.warn(
+        `Warning: Some requested locales are not supported: ${invalidTargets.join(", ")}`
+      );
+    }
+    targets = validTargets.filter((t) => t !== primaryLocale);
+  }
+  return targets;
+}
+function buildTranslationTasks(slug, screenshots, primaryLocale, targetLocales, skipExisting) {
+  const tasks = [];
+  const screenshotsDir = getScreenshotsDir(slug);
+  for (const targetLocale of targetLocales) {
+    for (const screenshot of screenshots) {
+      const outputPath = path11.join(
+        screenshotsDir,
+        targetLocale,
+        screenshot.type,
+        screenshot.filename
+      );
+      if (skipExisting && fs12.existsSync(outputPath)) {
+        continue;
+      }
+      tasks.push({
+        sourcePath: screenshot.fullPath,
+        sourceLocale: primaryLocale,
+        targetLocale,
+        outputPath,
+        deviceType: screenshot.type,
+        filename: screenshot.filename
+      });
+    }
+  }
+  return tasks;
+}
+async function handleLocalizeScreenshots(input) {
+  const {
+    appName,
+    targetLocales: requestedTargetLocales,
+    deviceTypes = ["phone", "tablet"],
+    dryRun = false,
+    skipExisting = true
+  } = input;
+  const results = [];
+  let appInfo;
+  try {
+    appInfo = validateApp(appName);
+    results.push(`\u2705 App found: ${appInfo.name} (${appInfo.slug})`);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\u274C ${error instanceof Error ? error.message : String(error)}`
+        }
+      ]
+    };
+  }
+  let primaryLocale;
+  let allLocales;
+  try {
+    const localeInfo = getSupportedLocales(appInfo.slug);
+    primaryLocale = localeInfo.primaryLocale;
+    allLocales = localeInfo.allLocales;
+    results.push(`\u{1F4CD} Primary locale: ${primaryLocale}`);
+    results.push(`\u{1F310} Supported locales: ${allLocales.join(", ")}`);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\u274C ${error instanceof Error ? error.message : String(error)}`
+        }
+      ]
+    };
+  }
+  const targetLocales = getTargetLocales(
+    allLocales,
+    primaryLocale,
+    requestedTargetLocales
+  );
+  if (targetLocales.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\u274C No target locales to translate to. Primary locale: ${primaryLocale}, Available: ${allLocales.join(", ")}`
+        }
+      ]
+    };
+  }
+  results.push(`\u{1F3AF} Target locales: ${targetLocales.join(", ")}`);
+  const sourceScreenshots = scanLocaleScreenshots(appInfo.slug, primaryLocale);
+  const filteredScreenshots = sourceScreenshots.filter(
+    (s) => deviceTypes.includes(s.type)
+  );
+  if (filteredScreenshots.length === 0) {
+    const screenshotsDir2 = getScreenshotsDir(appInfo.slug);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\u274C No screenshots found in ${screenshotsDir2}/${primaryLocale}/
+
+Expected structure:
+${screenshotsDir2}/${primaryLocale}/phone/1.png, 2.png, ...
+${screenshotsDir2}/${primaryLocale}/tablet/1.png, 2.png, ...`
+        }
+      ]
+    };
+  }
+  const phoneCount = filteredScreenshots.filter((s) => s.type === "phone").length;
+  const tabletCount = filteredScreenshots.filter((s) => s.type === "tablet").length;
+  results.push(`\u{1F4F8} Source screenshots: ${phoneCount} phone, ${tabletCount} tablet`);
+  const tasks = buildTranslationTasks(
+    appInfo.slug,
+    filteredScreenshots,
+    primaryLocale,
+    targetLocales,
+    skipExisting
+  );
+  if (tasks.length === 0) {
+    results.push(`
+\u2705 All screenshots already translated (skipExisting=true)`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: results.join("\n")
+        }
+      ]
+    };
+  }
+  results.push(`
+\u{1F4CB} Translation tasks: ${tasks.length} images to translate`);
+  if (dryRun) {
+    results.push(`
+\u{1F50D} DRY RUN - No actual translations will be performed
+`);
+    const tasksByLocale = {};
+    for (const task of tasks) {
+      if (!tasksByLocale[task.targetLocale]) {
+        tasksByLocale[task.targetLocale] = [];
+      }
+      tasksByLocale[task.targetLocale].push(task);
+    }
+    for (const [locale, localeTasks] of Object.entries(tasksByLocale)) {
+      results.push(`
+\u{1F4C1} ${locale}:`);
+      for (const task of localeTasks) {
+        results.push(`   - ${task.deviceType}/${task.filename}`);
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: results.join("\n")
+        }
+      ]
+    };
+  }
+  results.push(`
+\u{1F680} Starting translations...`);
+  const translationResult = await translateImagesWithProgress(
+    tasks,
+    (progress) => {
+      if (progress.status === "completed") {
+        console.log(
+          `\u2705 ${progress.targetLocale}/${progress.deviceType}/${progress.filename}`
+        );
+      } else if (progress.status === "failed") {
+        console.log(
+          `\u274C ${progress.targetLocale}/${progress.deviceType}/${progress.filename}: ${progress.error}`
+        );
+      }
+    }
+  );
+  results.push(`
+\u{1F4CA} Translation Results:`);
+  results.push(`   \u2705 Successful: ${translationResult.successful}`);
+  results.push(`   \u274C Failed: ${translationResult.failed}`);
+  if (translationResult.errors.length > 0) {
+    results.push(`
+\u26A0\uFE0F Errors:`);
+    for (const err of translationResult.errors.slice(0, 5)) {
+      results.push(`   - ${path11.basename(err.path)}: ${err.error}`);
+    }
+    if (translationResult.errors.length > 5) {
+      results.push(`   ... and ${translationResult.errors.length - 5} more errors`);
+    }
+  }
+  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 resizeResult = await batchValidateAndResize(resizePairs);
+    if (resizeResult.resized > 0) {
+      results.push(`   \u{1F527} Resized ${resizeResult.resized} images to match source dimensions`);
+    } else {
+      results.push(`   \u2705 All image dimensions match source`);
+    }
+    if (resizeResult.errors.length > 0) {
+      results.push(`   \u26A0\uFE0F Resize errors: ${resizeResult.errors.length}`);
+    }
+  }
+  const screenshotsDir = getScreenshotsDir(appInfo.slug);
+  results.push(`
+\u{1F4C1} Output location: ${screenshotsDir}/`);
+  results.push(`
+\u2705 Screenshot localization complete!`);
+  return {
+    content: [
+      {
+        type: "text",
+        text: results.join("\n")
+      }
+    ]
+  };
+}
+
+// src/tools/apps/init.ts
+import fs13 from "fs";
+import path12 from "path";
+import { z as z8 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema8 } from "zod-to-json-schema";
 var listSlugDirs = (dir) => {
-  if (!fs9.existsSync(dir)) return [];
-  return fs9.readdirSync(dir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+  if (!fs13.existsSync(dir)) return [];
+  return fs13.readdirSync(dir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
 };
-var initProjectInputSchema = z7.object({
-  slug: z7.string().trim().optional().describe(
+var initProjectInputSchema = z8.object({
+  slug: z8.string().trim().optional().describe(
     "Optional product slug to focus on. Defaults to all slugs in .aso/pullData/products/"
   )
 });
-var jsonSchema7 = zodToJsonSchema7(initProjectInputSchema, {
+var jsonSchema8 = zodToJsonSchema8(initProjectInputSchema, {
   name: "InitProjectInput",
   $refStrategy: "none"
 });
-var inputSchema7 = jsonSchema7.definitions?.InitProjectInput || jsonSchema7;
+var inputSchema8 = jsonSchema8.definitions?.InitProjectInput || jsonSchema8;
 var initProjectTool = {
   name: "init-project",
   description: `Guides the initialization flow: run pabal-store-api-mcp Init, then convert ASO pullData into public/products/[slug]/.
@@ -3413,10 +4015,10 @@ Steps:
 1) Ensure pabal-store-api-mcp 'init' ran and .aso/pullData/products/[slug]/ exists (path from ~/.config/pabal-mcp/config.json dataDir)
 2) Convert pulled ASO data -> public/products/[slug]/ using pabal-resource-mcp tools (aso-to-public, public-to-aso dry run)
 3) Validate outputs and next actions`,
-  inputSchema: inputSchema7
+  inputSchema: inputSchema8
 };
 async function handleInitProject(input) {
-  const pullDataDir = path9.join(getPullDataDir(), "products");
+  const pullDataDir = path12.join(getPullDataDir(), "products");
   const publicDir = getProductsDir();
   const pullDataSlugs = listSlugDirs(pullDataDir);
   const publicSlugs = listSlugDirs(publicDir);
@@ -3494,14 +4096,14 @@ async function handleInitProject(input) {
 }
 
 // src/tools/content/create-blog-html.ts
-import fs11 from "fs";
-import path11 from "path";
-import { z as z8 } from "zod";
-import { zodToJsonSchema as zodToJsonSchema8 } from "zod-to-json-schema";
+import fs15 from "fs";
+import path14 from "path";
+import { z as z9 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema9 } from "zod-to-json-schema";
 
 // src/utils/blog.util.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs14 from "fs";
+import path13 from "path";
 var DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
 var BLOG_ROOT = "blogs";
 var removeDiacritics = (value) => value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "");
@@ -3589,13 +4191,13 @@ function resolveTargetLocales(input) {
   return fallback ? [fallback] : [];
 }
 function getBlogOutputPaths(options) {
-  const baseDir = path10.join(
+  const baseDir = path13.join(
     options.publicDir,
     BLOG_ROOT,
     options.appSlug,
     options.slug
   );
-  const filePath = path10.join(baseDir, `${options.locale}.html`);
+  const filePath = path13.join(baseDir, `${options.locale}.html`);
   const publicBasePath = toPublicBlogBase(options.appSlug, options.slug);
   return { baseDir, filePath, publicBasePath };
 }
@@ -3620,18 +4222,18 @@ function findExistingBlogPosts({
   publicDir,
   limit = 2
 }) {
-  const blogAppDir = path10.join(publicDir, BLOG_ROOT, appSlug);
-  if (!fs10.existsSync(blogAppDir)) {
+  const blogAppDir = path13.join(publicDir, BLOG_ROOT, appSlug);
+  if (!fs14.existsSync(blogAppDir)) {
     return [];
   }
   const posts = [];
-  const subdirs = fs10.readdirSync(blogAppDir, { withFileTypes: true });
+  const subdirs = fs14.readdirSync(blogAppDir, { withFileTypes: true });
   for (const subdir of subdirs) {
     if (!subdir.isDirectory()) continue;
-    const localeFile = path10.join(blogAppDir, subdir.name, `${locale}.html`);
-    if (!fs10.existsSync(localeFile)) continue;
+    const localeFile = path13.join(blogAppDir, subdir.name, `${locale}.html`);
+    if (!fs14.existsSync(localeFile)) continue;
     try {
-      const htmlContent = fs10.readFileSync(localeFile, "utf-8");
+      const htmlContent = fs14.readFileSync(localeFile, "utf-8");
       const { meta, body } = parseBlogHtml(htmlContent);
       if (meta && meta.locale === locale) {
         posts.push({
@@ -3658,43 +4260,43 @@ function findExistingBlogPosts({
 }
 
 // src/tools/content/create-blog-html.ts
-var toJsonSchema5 = zodToJsonSchema8;
+var toJsonSchema5 = zodToJsonSchema9;
 var DATE_REGEX2 = /^\d{4}-\d{2}-\d{2}$/;
-var createBlogHtmlInputSchema = z8.object({
-  appSlug: z8.string().trim().min(1).default(DEFAULT_APP_SLUG).describe(
+var createBlogHtmlInputSchema = z9.object({
+  appSlug: z9.string().trim().min(1).default(DEFAULT_APP_SLUG).describe(
     `Product/app slug used for paths and CTAs. Defaults to "${DEFAULT_APP_SLUG}" when not provided.`
   ),
-  title: z8.string().trim().optional().describe(
+  title: z9.string().trim().optional().describe(
     "English title used for slug (kebab-case). Falls back to topic when omitted."
   ),
-  topic: z8.string().trim().min(1, "topic is required").describe("Topic/angle to write about in the blog body"),
-  locale: z8.string().trim().min(1, "locale is required").describe(
+  topic: z9.string().trim().min(1, "topic is required").describe("Topic/angle to write about in the blog body"),
+  locale: z9.string().trim().min(1, "locale is required").describe(
     "Primary locale (e.g., 'en-US', 'ko-KR'). Required to determine the language for blog content generation."
   ),
-  locales: z8.array(z8.string().trim().min(1)).optional().describe(
+  locales: z9.array(z9.string().trim().min(1)).optional().describe(
     "Optional list of locales to generate. Each locale gets its own HTML file. If provided, locale parameter is ignored."
   ),
-  content: z8.string().trim().min(1, "content is required").describe(
+  content: z9.string().trim().min(1, "content is required").describe(
     "HTML content for the blog body. You (the LLM) must generate this HTML content based on the topic and locale. Structure should follow the pattern in public/en-US.html: paragraphs (<p>), headings (<h2>, <h3>), images (<img>), lists (<ul>, <li>), horizontal rules (<hr>), etc. The content should be written in the language corresponding to the locale."
   ),
-  description: z8.string().trim().min(1, "description is required").describe(
+  description: z9.string().trim().min(1, "description is required").describe(
     "Meta description for the blog post. You (the LLM) must generate this based on the topic and locale. Should be a concise summary of the blog content in the language corresponding to the locale."
   ),
-  tags: z8.array(z8.string().trim().min(1)).optional().describe(
+  tags: z9.array(z9.string().trim().min(1)).optional().describe(
     "Optional tags for BLOG_META. Defaults to tags derived from topic."
   ),
-  coverImage: z8.string().trim().optional().describe(
+  coverImage: z9.string().trim().optional().describe(
     "Cover image path. Relative paths rewrite to /blogs/<app>/<slug>/..., default is /products/<appSlug>/og-image.png."
   ),
-  publishedAt: z8.string().trim().regex(DATE_REGEX2, "publishedAt must use YYYY-MM-DD").optional().describe("Publish date (YYYY-MM-DD). Defaults to today."),
-  modifiedAt: z8.string().trim().regex(DATE_REGEX2, "modifiedAt must use YYYY-MM-DD").optional().describe("Last modified date (YYYY-MM-DD). Defaults to publishedAt."),
-  overwrite: z8.boolean().optional().default(false).describe("Overwrite existing files when true (default: false).")
+  publishedAt: z9.string().trim().regex(DATE_REGEX2, "publishedAt must use YYYY-MM-DD").optional().describe("Publish date (YYYY-MM-DD). Defaults to today."),
+  modifiedAt: z9.string().trim().regex(DATE_REGEX2, "modifiedAt must use YYYY-MM-DD").optional().describe("Last modified date (YYYY-MM-DD). Defaults to publishedAt."),
+  overwrite: z9.boolean().optional().default(false).describe("Overwrite existing files when true (default: false).")
 }).describe("Generate static HTML blog posts with BLOG_META headers.");
-var jsonSchema8 = toJsonSchema5(createBlogHtmlInputSchema, {
+var jsonSchema9 = toJsonSchema5(createBlogHtmlInputSchema, {
   name: "CreateBlogHtmlInput",
   $refStrategy: "none"
 });
-var inputSchema8 = jsonSchema8.definitions?.CreateBlogHtmlInput || jsonSchema8;
+var inputSchema9 = jsonSchema9.definitions?.CreateBlogHtmlInput || jsonSchema9;
 var createBlogHtmlTool = {
   name: "create-blog-html",
   description: `Generate HTML blog posts under public/blogs/<appSlug>/<slug>/<locale>.html with a BLOG_META block.
@@ -3731,7 +4333,7 @@ Supports multiple locales when locales[] is provided. Each locale gets its own H
 1. Read existing posts in that locale to understand the writing style
 2. Generate appropriate content in that locale's language
 3. Match the writing style and format of existing posts`,
-  inputSchema: inputSchema8
+  inputSchema: inputSchema9
 };
 async function handleCreateBlogHtml(input) {
   const publicDir = getPublicDir();
@@ -3774,7 +4376,7 @@ async function handleCreateBlogHtml(input) {
   }
   const output = {
     slug,
-    baseDir: path11.join(publicDir, "blogs", appSlug, slug),
+    baseDir: path14.join(publicDir, "blogs", appSlug, slug),
     files: [],
     coverImage: coverImage && coverImage.trim().length > 0 ? coverImage.trim() : `/products/${appSlug}/og-image.png`,
     metaByLocale: {}
@@ -3788,7 +4390,7 @@ async function handleCreateBlogHtml(input) {
     })
   );
   const existing = plannedFiles.filter(
-    ({ filePath }) => fs11.existsSync(filePath)
+    ({ filePath }) => fs15.existsSync(filePath)
   );
   if (existing.length > 0 && !overwrite) {
     const existingList = existing.map((f) => f.filePath).join("\n- ");
@@ -3797,7 +4399,7 @@ async function handleCreateBlogHtml(input) {
 - ${existingList}`
     );
   }
-  fs11.mkdirSync(output.baseDir, { recursive: true });
+  fs15.mkdirSync(output.baseDir, { recursive: true });
   for (const locale of targetLocales) {
     const { filePath } = getBlogOutputPaths({
       appSlug,
@@ -3823,7 +4425,7 @@ async function handleCreateBlogHtml(input) {
       meta,
       content
     });
-    fs11.writeFileSync(filePath, html, "utf-8");
+    fs15.writeFileSync(filePath, html, "utf-8");
     output.files.push({ locale, path: filePath });
   }
   const summaryLines = [
@@ -3902,6 +4504,14 @@ var tools = [
     handler: handleKeywordResearch,
     category: "aso"
   },
+  {
+    name: localizeScreenshotsTool.name,
+    description: localizeScreenshotsTool.description,
+    inputSchema: localizeScreenshotsTool.inputSchema,
+    zodSchema: localizeScreenshotsInputSchema,
+    handler: handleLocalizeScreenshots,
+    category: "aso"
+  },
   // Apps Tools
   {
     name: initProjectTool.name,
@@ -3937,6 +4547,7 @@ function getToolDefinitions() {
     initProjectTool,
     createBlogHtmlTool,
     keywordResearchTool,
+    localizeScreenshotsTool,
     searchAppTool,
     validateAsoTool
   ];

package/dist/chunk-YKUBCCJA.js

@@ -0,0 +1,386 @@
+import {
+  DEFAULT_LOCALE,
+  isAppStoreLocale,
+  isGooglePlayLocale,
+  isSupportedLocale
+} from "./chunk-BOWRBVVV.js";
+
+// src/utils/config.util.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+function getAsoDataDir() {
+  const configPath = path.join(
+    os.homedir(),
+    ".config",
+    "pabal-mcp",
+    "config.json"
+  );
+  if (!fs.existsSync(configPath)) {
+    throw new Error(
+      `Config file not found at ${configPath}. Please create the config file and set the 'dataDir' property to specify the ASO data directory.`
+    );
+  }
+  try {
+    const configContent = fs.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(configContent);
+    if (!config.dataDir) {
+      throw new Error(
+        `'dataDir' property is not set in ${configPath}. Please set 'dataDir' to specify the ASO data directory.`
+      );
+    }
+    if (path.isAbsolute(config.dataDir)) {
+      return config.dataDir;
+    }
+    return path.resolve(os.homedir(), config.dataDir);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("dataDir")) {
+      throw error;
+    }
+    throw new Error(
+      `Failed to read config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function getPullDataDir() {
+  return path.join(getAsoDataDir(), ".aso", "pullData");
+}
+function getPushDataDir() {
+  return path.join(getAsoDataDir(), ".aso", "pushData");
+}
+function getPublicDir() {
+  return path.join(getAsoDataDir(), "public");
+}
+function getKeywordResearchDir() {
+  return path.join(getAsoDataDir(), ".aso", "keywordResearch");
+}
+function getProductsDir() {
+  return path.join(getPublicDir(), "products");
+}
+function loadConfig() {
+  const configPath = path.join(
+    os.homedir(),
+    ".config",
+    "pabal-mcp",
+    "config.json"
+  );
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+  try {
+    const configContent = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(configContent);
+  } catch {
+    return {};
+  }
+}
+function getGeminiApiKey() {
+  const config = loadConfig();
+  if (config.gemini?.apiKey) {
+    return config.gemini.apiKey;
+  }
+  const envKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
+  if (envKey) {
+    return envKey;
+  }
+  throw new Error(
+    `Gemini API key not found. Set it in ~/.config/pabal-mcp/config.json under "gemini.apiKey" or use GEMINI_API_KEY environment variable.`
+  );
+}
+
+// src/utils/aso-converter.ts
+import fs2 from "fs";
+import path2 from "path";
+function generateFullDescription(localeData, metadata = {}) {
+  const { aso, landing } = localeData;
+  const template = aso?.template;
+  if (!template) {
+    return "";
+  }
+  const landingFeatures = landing?.features?.items || [];
+  const landingScreenshots = landing?.screenshots?.images || [];
+  const keyHeading = template.keyFeaturesHeading || "Key Features";
+  const featuresHeading = template.featuresHeading || "Additional Features";
+  const parts = [template.intro];
+  if (landingFeatures.length > 0) {
+    parts.push(
+      "",
+      keyHeading,
+      "",
+      ...landingFeatures.map(
+        (feature) => [`\u25B6\uFE0E ${feature.title}`, feature.body || ""].filter(Boolean).join("\n")
+      )
+    );
+  }
+  if (landingScreenshots.length > 0) {
+    parts.push("", featuresHeading, "");
+    parts.push(
+      ...landingScreenshots.map(
+        (screenshot) => [`\u25B6\uFE0E ${screenshot.title}`, screenshot.description || ""].filter(Boolean).join("\n")
+      )
+    );
+  }
+  parts.push("", template.outro);
+  const includeSupport = template.includeSupportLinks ?? true;
+  if (includeSupport) {
+    const contactLines = [
+      metadata.instagram ? `Instagram: ${metadata.instagram}` : null,
+      metadata.contactEmail ? `Email: ${metadata.contactEmail}` : null,
+      metadata.termsUrl ? `- Terms of Use: ${metadata.termsUrl}` : null,
+      metadata.privacyUrl ? `- Privacy Policy: ${metadata.privacyUrl}` : null
+    ].filter((line) => line !== null);
+    if (contactLines.length > 0) {
+      parts.push("", "[Contact & Support]", "", ...contactLines);
+    }
+  }
+  return parts.join("\n");
+}
+function loadAsoFromConfig(slug) {
+  const productsDir = getProductsDir();
+  const configPath = path2.join(productsDir, slug, "config.json");
+  console.debug(`[loadAsoFromConfig] Looking for ${slug}:`);
+  console.debug(`  - productsDir: ${productsDir}`);
+  console.debug(`  - configPath: ${configPath}`);
+  console.debug(`  - configPath exists: ${fs2.existsSync(configPath)}`);
+  if (!fs2.existsSync(configPath)) {
+    console.warn(`[loadAsoFromConfig] Config file not found at ${configPath}`);
+    return {};
+  }
+  try {
+    const configContent = fs2.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(configContent);
+    const localesDir = path2.join(productsDir, slug, "locales");
+    console.debug(`  - localesDir: ${localesDir}`);
+    console.debug(`  - localesDir exists: ${fs2.existsSync(localesDir)}`);
+    if (!fs2.existsSync(localesDir)) {
+      console.warn(
+        `[loadAsoFromConfig] Locales directory not found at ${localesDir}`
+      );
+      return {};
+    }
+    const localeFiles = fs2.readdirSync(localesDir).filter((f) => f.endsWith(".json"));
+    const locales = {};
+    for (const file of localeFiles) {
+      const localeCode = file.replace(".json", "");
+      const localePath = path2.join(localesDir, file);
+      const localeContent = fs2.readFileSync(localePath, "utf-8");
+      locales[localeCode] = JSON.parse(localeContent);
+    }
+    console.debug(
+      `  - Found ${Object.keys(locales).length} locale file(s): ${Object.keys(
+        locales
+      ).join(", ")}`
+    );
+    if (Object.keys(locales).length === 0) {
+      console.warn(
+        `[loadAsoFromConfig] No locale files found in ${localesDir}`
+      );
+    }
+    const defaultLocale = config.content?.defaultLocale || DEFAULT_LOCALE;
+    const asoData = {};
+    if (config.packageName) {
+      const googlePlayLocales = {};
+      const metadata = config.metadata || {};
+      const screenshots = metadata.screenshots || {};
+      for (const [locale, localeData] of Object.entries(locales)) {
+        if (!isSupportedLocale(locale)) {
+          console.debug(
+            `Skipping locale ${locale} - not a valid unified locale`
+          );
+          continue;
+        }
+        if (!isGooglePlayLocale(locale)) {
+          console.debug(
+            `Skipping locale ${locale} - not supported by Google Play`
+          );
+          continue;
+        }
+        const aso = localeData.aso || {};
+        if (!aso || !aso.title && !aso.shortDescription) {
+          console.warn(
+            `Locale ${locale} has no ASO data (title or shortDescription)`
+          );
+        }
+        const localeScreenshots = {
+          phone: screenshots.phone?.map(
+            (p) => p.replace("/screenshots/", `/screenshots/${locale}/`)
+          ),
+          tablet: screenshots.tablet?.map(
+            (p) => p.replace("/screenshots/", `/screenshots/${locale}/`)
+          )
+        };
+        googlePlayLocales[locale] = {
+          title: aso.title || "",
+          shortDescription: aso.shortDescription || "",
+          fullDescription: generateFullDescription(localeData, metadata),
+          packageName: config.packageName,
+          defaultLanguage: locale,
+          screenshots: {
+            phone: localeScreenshots.phone || [],
+            tablet: localeScreenshots.tablet
+          },
+          contactEmail: metadata.contactEmail
+        };
+      }
+      const googleLocaleKeys = Object.keys(googlePlayLocales);
+      if (googleLocaleKeys.length > 0) {
+        const hasConfigDefault = isGooglePlayLocale(defaultLocale) && Boolean(googlePlayLocales[defaultLocale]);
+        const resolvedDefault = hasConfigDefault ? defaultLocale : googlePlayLocales[DEFAULT_LOCALE] ? DEFAULT_LOCALE : googleLocaleKeys[0];
+        asoData.googlePlay = {
+          locales: googlePlayLocales,
+          defaultLocale: resolvedDefault
+        };
+      }
+    }
+    if (config.bundleId) {
+      const appStoreLocales = {};
+      const metadata = config.metadata || {};
+      const screenshots = metadata.screenshots || {};
+      for (const [locale, localeData] of Object.entries(locales)) {
+        if (!isSupportedLocale(locale)) {
+          console.debug(
+            `Skipping locale ${locale} - not a valid unified locale`
+          );
+          continue;
+        }
+        if (!isAppStoreLocale(locale)) {
+          console.debug(
+            `Skipping locale ${locale} - not supported by App Store`
+          );
+          continue;
+        }
+        const aso = localeData.aso || {};
+        if (!aso || !aso.title && !aso.shortDescription) {
+          console.warn(
+            `Locale ${locale} has no ASO data (title or shortDescription)`
+          );
+        }
+        const localeScreenshots = {
+          phone: screenshots.phone?.map(
+            (p) => p.replace("/screenshots/", `/screenshots/${locale}/`)
+          ),
+          tablet: screenshots.tablet?.map(
+            (p) => p.replace("/screenshots/", `/screenshots/${locale}/`)
+          )
+        };
+        appStoreLocales[locale] = {
+          name: aso.title || "",
+          subtitle: aso.subtitle,
+          description: generateFullDescription(localeData, metadata),
+          keywords: Array.isArray(aso.keywords) ? aso.keywords.join(", ") : aso.keywords,
+          promotionalText: void 0,
+          bundleId: config.bundleId,
+          locale,
+          supportUrl: metadata.supportUrl,
+          marketingUrl: metadata.marketingUrl,
+          privacyPolicyUrl: metadata.privacyUrl,
+          screenshots: {
+            // 폰 스크린샷을 iphone65로 매핑
+            iphone65: localeScreenshots.phone || [],
+            // 태블릿 스크린샷을 ipadPro129로 매핑
+            ipadPro129: localeScreenshots.tablet
+          }
+        };
+      }
+      const appStoreLocaleKeys = Object.keys(appStoreLocales);
+      if (appStoreLocaleKeys.length > 0) {
+        const hasConfigDefault = isAppStoreLocale(defaultLocale) && Boolean(appStoreLocales[defaultLocale]);
+        const resolvedDefault = hasConfigDefault ? defaultLocale : appStoreLocales[DEFAULT_LOCALE] ? DEFAULT_LOCALE : appStoreLocaleKeys[0];
+        asoData.appStore = {
+          locales: appStoreLocales,
+          defaultLocale: resolvedDefault
+        };
+      }
+    }
+    const hasGooglePlay = !!asoData.googlePlay;
+    const hasAppStore = !!asoData.appStore;
+    console.debug(`[loadAsoFromConfig] Result for ${slug}:`);
+    console.debug(
+      `  - Google Play data: ${hasGooglePlay ? "found" : "not found"}`
+    );
+    console.debug(`  - App Store data: ${hasAppStore ? "found" : "not found"}`);
+    if (!hasGooglePlay && !hasAppStore) {
+      console.warn(`[loadAsoFromConfig] No ASO data generated for ${slug}`);
+    }
+    return asoData;
+  } catch (error) {
+    console.error(
+      `[loadAsoFromConfig] Failed to load ASO data from config for ${slug}:`,
+      error
+    );
+    return {};
+  }
+}
+function saveAsoToConfig(slug, config) {
+  const productsDir = getProductsDir();
+  const configPath = path2.join(productsDir, slug, "config.json");
+  fs2.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function saveAsoToAsoDir(slug, asoData) {
+  const rootDir = getPushDataDir();
+  if (asoData.googlePlay) {
+    const asoPath = path2.join(
+      rootDir,
+      "products",
+      slug,
+      "store",
+      "google-play",
+      "aso-data.json"
+    );
+    const dir = path2.dirname(asoPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    const googlePlayData = asoData.googlePlay;
+    const multilingualData = "locales" in googlePlayData ? googlePlayData : {
+      locales: {
+        [googlePlayData.defaultLanguage || DEFAULT_LOCALE]: googlePlayData
+      },
+      defaultLocale: googlePlayData.defaultLanguage || DEFAULT_LOCALE
+    };
+    fs2.writeFileSync(
+      asoPath,
+      JSON.stringify({ googlePlay: multilingualData }, null, 2) + "\n",
+      "utf-8"
+    );
+  }
+  if (asoData.appStore) {
+    const asoPath = path2.join(
+      rootDir,
+      "products",
+      slug,
+      "store",
+      "app-store",
+      "aso-data.json"
+    );
+    const dir = path2.dirname(asoPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    const appStoreData = asoData.appStore;
+    const multilingualData = "locales" in appStoreData ? appStoreData : {
+      locales: {
+        [appStoreData.locale || DEFAULT_LOCALE]: appStoreData
+      },
+      defaultLocale: appStoreData.locale || DEFAULT_LOCALE
+    };
+    fs2.writeFileSync(
+      asoPath,
+      JSON.stringify({ appStore: multilingualData }, null, 2) + "\n",
+      "utf-8"
+    );
+  }
+}
+
+export {
+  getAsoDataDir,
+  getPullDataDir,
+  getPushDataDir,
+  getPublicDir,
+  getKeywordResearchDir,
+  getProductsDir,
+  getGeminiApiKey,
+  loadAsoFromConfig,
+  saveAsoToConfig,
+  saveAsoToAsoDir
+};

package/dist/index.d.ts

@@ -48,5 +48,10 @@ declare function getKeywordResearchDir(): string;
  * Get the products directory path (dataDir/public/products)
  */
 declare function getProductsDir(): string;
+/**
+ * Get the Gemini API key from config.json or environment variable
+ * Priority: config.json > GEMINI_API_KEY > GOOGLE_API_KEY
+ */
+declare function getGeminiApiKey(): string;
 
-export { AsoData, ProductConfig, getAsoDataDir, getKeywordResearchDir, getProductsDir, getPublicDir, getPullDataDir, getPushDataDir, loadAsoFromConfig, saveAsoToAsoDir, saveAsoToConfig };
+export { AsoData, ProductConfig, getAsoDataDir, getGeminiApiKey, getKeywordResearchDir, getProductsDir, getPublicDir, getPullDataDir, getPushDataDir, loadAsoFromConfig, saveAsoToAsoDir, saveAsoToConfig };

package/dist/index.js

@@ -1,5 +1,6 @@
 import {
   getAsoDataDir,
+  getGeminiApiKey,
   getKeywordResearchDir,
   getProductsDir,
   getPublicDir,
@@ -8,7 +9,7 @@ import {
   loadAsoFromConfig,
   saveAsoToAsoDir,
   saveAsoToConfig
-} from "./chunk-W62HB2ZL.js";
+} from "./chunk-YKUBCCJA.js";
 import {
   APP_STORE_TO_UNIFIED,
   DEFAULT_LOCALE,
@@ -52,6 +53,7 @@ export {
   convertObjectToAppStore,
   convertObjectToGooglePlay,
   getAsoDataDir,
+  getGeminiApiKey,
   getKeywordResearchDir,
   getProductsDir,
   getPublicDir,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pabal-resource-mcp",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "type": "module",
   "description": "MCP server for ASO data management with shared types and utilities",
   "author": "skyu",
@@ -61,14 +61,17 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@google/genai": "^1.38.0",
     "@googleapis/androidpublisher": "^33.2.0",
     "@modelcontextprotocol/sdk": "^1.22.0",
     "appstore-connect-sdk": "^1.3.2",
+    "sharp": "^0.34.5",
     "zod": "^3.25.76",
     "zod-to-json-schema": "^3.25.0"
   },
   "devDependencies": {
     "@types/node": "^20.11.30",
+    "@types/sharp": "^0.31.1",
     "tsup": "^8.0.0",
     "tsx": "^4.20.6",
     "typescript": "^5.4.5"