pabal-web-mcp 1.4.5 → 1.4.7

package/dist/bin/mcp-server.js

@@ -352,6 +352,209 @@ import { z as z2 } from "zod";
 import { zodToJsonSchema as zodToJsonSchema2 } from "zod-to-json-schema";
 import path4 from "path";
 
+// src/utils/aso-validation.util.ts
+var FIELD_LIMITS_DOC_PATH = "docs/aso/ASO_FIELD_LIMITS.md";
+var APP_STORE_LIMITS = {
+  name: 30,
+  subtitle: 30,
+  keywords: 100,
+  promotionalText: 170,
+  description: 4e3,
+  whatsNew: 4e3
+};
+var GOOGLE_PLAY_LIMITS = {
+  title: 50,
+  shortDescription: 80,
+  fullDescription: 4e3,
+  releaseNotes: 500
+};
+var INVALID_CHAR_REGEX = /[\u0000-\u0008\u000B-\u000C\u000E-\u001F\u007F-\u009F\uFEFF\u200B-\u200F\u202A-\u202E\u2060\uFE00-\uFE0F]/g;
+function sanitizeText(value, fieldPath, warnings) {
+  if (typeof value !== "string") return value;
+  const cleaned = value.replace(INVALID_CHAR_REGEX, "");
+  if (cleaned !== value) {
+    warnings.push(`Removed invalid characters from ${fieldPath}`);
+  }
+  return cleaned;
+}
+function sanitizeAsoData(configData) {
+  const sanitizedData = JSON.parse(JSON.stringify(configData));
+  const warnings = [];
+  if (sanitizedData.appStore) {
+    const appStoreData = sanitizedData.appStore;
+    const locales = isAppStoreMultilingual(appStoreData) ? appStoreData.locales : { [appStoreData.locale || DEFAULT_LOCALE]: appStoreData };
+    for (const [locale, data] of Object.entries(locales)) {
+      data.name = sanitizeText(
+        data.name,
+        `App Store [${locale}].name`,
+        warnings
+      );
+      data.subtitle = sanitizeText(
+        data.subtitle,
+        `App Store [${locale}].subtitle`,
+        warnings
+      );
+      data.keywords = sanitizeText(
+        data.keywords,
+        `App Store [${locale}].keywords`,
+        warnings
+      );
+      data.promotionalText = sanitizeText(
+        data.promotionalText,
+        `App Store [${locale}].promotionalText`,
+        warnings
+      );
+      data.description = sanitizeText(
+        data.description,
+        `App Store [${locale}].description`,
+        warnings
+      );
+      data.whatsNew = sanitizeText(
+        data.whatsNew,
+        `App Store [${locale}].whatsNew`,
+        warnings
+      );
+    }
+  }
+  if (sanitizedData.googlePlay) {
+    const googlePlayData = sanitizedData.googlePlay;
+    const locales = isGooglePlayMultilingual(googlePlayData) ? googlePlayData.locales : {
+      [googlePlayData.defaultLanguage || DEFAULT_LOCALE]: googlePlayData
+    };
+    for (const [locale, data] of Object.entries(locales)) {
+      data.title = sanitizeText(
+        data.title,
+        `Google Play [${locale}].title`,
+        warnings
+      );
+      data.shortDescription = sanitizeText(
+        data.shortDescription,
+        `Google Play [${locale}].shortDescription`,
+        warnings
+      );
+      data.fullDescription = sanitizeText(
+        data.fullDescription,
+        `Google Play [${locale}].fullDescription`,
+        warnings
+      );
+    }
+  }
+  return { sanitizedData, warnings };
+}
+function validateFieldLimits(configData) {
+  const issues = [];
+  if (configData.appStore) {
+    const appStoreData = configData.appStore;
+    const locales = isAppStoreMultilingual(appStoreData) ? appStoreData.locales : { [appStoreData.locale || DEFAULT_LOCALE]: appStoreData };
+    for (const [locale, data] of Object.entries(locales)) {
+      const checkField = (field, value) => {
+        if (typeof value === "string" && value.length > APP_STORE_LIMITS[field]) {
+          issues.push({
+            locale,
+            store: "appStore",
+            field,
+            currentLength: value.length,
+            limit: APP_STORE_LIMITS[field],
+            severity: "error"
+          });
+        }
+      };
+      checkField("name", data.name);
+      checkField("subtitle", data.subtitle);
+      checkField("keywords", data.keywords);
+      checkField("promotionalText", data.promotionalText);
+      checkField("description", data.description);
+      checkField("whatsNew", data.whatsNew);
+    }
+  }
+  if (configData.googlePlay) {
+    const googlePlayData = configData.googlePlay;
+    const locales = isGooglePlayMultilingual(googlePlayData) ? googlePlayData.locales : {
+      [googlePlayData.defaultLanguage || DEFAULT_LOCALE]: googlePlayData
+    };
+    for (const [locale, data] of Object.entries(locales)) {
+      const checkField = (field, value) => {
+        if (typeof value === "string" && value.length > GOOGLE_PLAY_LIMITS[field]) {
+          issues.push({
+            locale,
+            store: "googlePlay",
+            field,
+            currentLength: value.length,
+            limit: GOOGLE_PLAY_LIMITS[field],
+            severity: "error"
+          });
+        }
+      };
+      checkField("title", data.title);
+      checkField("shortDescription", data.shortDescription);
+      checkField("fullDescription", data.fullDescription);
+    }
+  }
+  return issues;
+}
+function formatValidationIssues(issues) {
+  if (issues.length === 0) {
+    return `\u2705 All fields within limits (checked against ${FIELD_LIMITS_DOC_PATH})`;
+  }
+  const grouped = {};
+  for (const issue of issues) {
+    const key = `${issue.store} [${issue.locale}]`;
+    if (!grouped[key]) grouped[key] = [];
+    grouped[key].push(issue);
+  }
+  const lines = [
+    `\u26A0\uFE0F Field limit violations (see ${FIELD_LIMITS_DOC_PATH}):`
+  ];
+  for (const [key, localeIssues] of Object.entries(grouped)) {
+    lines.push(`
+${key}:`);
+    for (const issue of localeIssues) {
+      const over = issue.currentLength - issue.limit;
+      lines.push(
+        `  - ${issue.field}: ${issue.currentLength}/${issue.limit} (${over} over)`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function checkKeywordDuplicates(keywords) {
+  const keywordList = keywords.split(",").map((k) => k.trim().toLowerCase()).filter(Boolean);
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = [];
+  const uniqueKeywords = [];
+  for (const keyword of keywordList) {
+    if (seen.has(keyword)) {
+      if (!duplicates.includes(keyword)) {
+        duplicates.push(keyword);
+      }
+    } else {
+      seen.add(keyword);
+      uniqueKeywords.push(keyword);
+    }
+  }
+  return {
+    hasDuplicates: duplicates.length > 0,
+    duplicates,
+    uniqueKeywords
+  };
+}
+function validateKeywords(configData) {
+  const issues = [];
+  if (configData.appStore) {
+    const appStoreData = configData.appStore;
+    const locales = isAppStoreMultilingual(appStoreData) ? appStoreData.locales : { [appStoreData.locale || DEFAULT_LOCALE]: appStoreData };
+    for (const [locale, data] of Object.entries(locales)) {
+      if (data.keywords) {
+        const result = checkKeywordDuplicates(data.keywords);
+        if (result.hasDuplicates) {
+          issues.push({ locale, duplicates: result.duplicates });
+        }
+      }
+    }
+  }
+  return issues;
+}
+
 // src/tools/utils/public-to-aso/prepare-aso-data-for-push.util.ts
 function prepareAsoDataForPush(slug, configData) {
   const storeData = {};
@@ -516,21 +719,6 @@ function convertToMultilingual(data, locale) {
 
 // src/tools/public-to-aso.ts
 import fs4 from "fs";
-var FIELD_LIMITS_DOC_PATH = "docs/aso/ASO_FIELD_LIMITS.md";
-var APP_STORE_LIMITS = {
-  name: 30,
-  subtitle: 30,
-  keywords: 100,
-  promotionalText: 170,
-  description: 4e3,
-  whatsNew: 4e3
-};
-var GOOGLE_PLAY_LIMITS = {
-  title: 50,
-  shortDescription: 80,
-  fullDescription: 4e3
-};
-var INVALID_CHAR_REGEX = /[\u0000-\u0008\u000B-\u000C\u000E-\u001F\u007F-\u009F\uFEFF\u200B-\u200F\u202A-\u202E\u2060\uFE00-\uFE0F]/g;
 var toJsonSchema2 = zodToJsonSchema2;
 var publicToAsoInputSchema = z2.object({
   slug: z2.string().describe("Product slug"),
@@ -541,121 +729,6 @@ var jsonSchema2 = toJsonSchema2(publicToAsoInputSchema, {
   $refStrategy: "none"
 });
 var inputSchema2 = jsonSchema2.definitions?.PublicToAsoInput || jsonSchema2;
-function sanitizeText(value, fieldPath, warnings) {
-  if (typeof value !== "string") {
-    return value;
-  }
-  const cleaned = value.replace(INVALID_CHAR_REGEX, "");
-  if (cleaned !== value) {
-    warnings.push(`Removed invalid characters from ${fieldPath}`);
-  }
-  return cleaned;
-}
-function sanitizeAsoData(configData) {
-  const sanitizedData = JSON.parse(JSON.stringify(configData));
-  const warnings = [];
-  if (sanitizedData.appStore) {
-    const appStoreData = sanitizedData.appStore;
-    const locales = isAppStoreMultilingual(appStoreData) ? appStoreData.locales : { [appStoreData.locale || DEFAULT_LOCALE]: appStoreData };
-    for (const [locale, data] of Object.entries(locales)) {
-      data.name = sanitizeText(data.name, `App Store [${locale}].name`, warnings);
-      data.subtitle = sanitizeText(
-        data.subtitle,
-        `App Store [${locale}].subtitle`,
-        warnings
-      );
-      data.keywords = sanitizeText(
-        data.keywords,
-        `App Store [${locale}].keywords`,
-        warnings
-      );
-      data.promotionalText = sanitizeText(
-        data.promotionalText,
-        `App Store [${locale}].promotionalText`,
-        warnings
-      );
-      data.description = sanitizeText(
-        data.description,
-        `App Store [${locale}].description`,
-        warnings
-      );
-      data.whatsNew = sanitizeText(
-        data.whatsNew,
-        `App Store [${locale}].whatsNew`,
-        warnings
-      );
-    }
-  }
-  if (sanitizedData.googlePlay) {
-    const googlePlayData = sanitizedData.googlePlay;
-    const locales = isGooglePlayMultilingual(googlePlayData) ? googlePlayData.locales : {
-      [googlePlayData.defaultLanguage || DEFAULT_LOCALE]: googlePlayData
-    };
-    for (const [locale, data] of Object.entries(locales)) {
-      data.title = sanitizeText(
-        data.title,
-        `Google Play [${locale}].title`,
-        warnings
-      );
-      data.shortDescription = sanitizeText(
-        data.shortDescription,
-        `Google Play [${locale}].shortDescription`,
-        warnings
-      );
-      data.fullDescription = sanitizeText(
-        data.fullDescription,
-        `Google Play [${locale}].fullDescription`,
-        warnings
-      );
-    }
-  }
-  return { sanitizedData, warnings };
-}
-function validateFieldLimits(configData) {
-  const issues = [];
-  if (configData.appStore) {
-    const appStoreData = configData.appStore;
-    const locales = isAppStoreMultilingual(appStoreData) ? appStoreData.locales : { [appStoreData.locale || DEFAULT_LOCALE]: appStoreData };
-    for (const [locale, data] of Object.entries(locales)) {
-      const { name, subtitle, keywords, promotionalText, description, whatsNew } = data;
-      const push = (field, value, limit) => {
-        if (typeof value === "string" && value.length > limit) {
-          issues.push(
-            `App Store [${locale}].${field}: ${value.length}/${limit}`
-          );
-        }
-      };
-      push("name", name, APP_STORE_LIMITS.name);
-      push("subtitle", subtitle, APP_STORE_LIMITS.subtitle);
-      push("keywords", keywords, APP_STORE_LIMITS.keywords);
-      push("promotionalText", promotionalText, APP_STORE_LIMITS.promotionalText);
-      push("description", description, APP_STORE_LIMITS.description);
-      push("whatsNew", whatsNew, APP_STORE_LIMITS.whatsNew);
-    }
-  }
-  if (configData.googlePlay) {
-    const googlePlayData = configData.googlePlay;
-    const locales = isGooglePlayMultilingual(googlePlayData) ? googlePlayData.locales : { [googlePlayData.defaultLanguage || DEFAULT_LOCALE]: googlePlayData };
-    for (const [locale, data] of Object.entries(locales)) {
-      const { title, shortDescription, fullDescription } = data;
-      const push = (field, value, limit) => {
-        if (typeof value === "string" && value.length > limit) {
-          issues.push(
-            `Google Play [${locale}].${field}: ${value.length}/${limit}`
-          );
-        }
-      };
-      push("title", title, GOOGLE_PLAY_LIMITS.title);
-      push(
-        "shortDescription",
-        shortDescription,
-        GOOGLE_PLAY_LIMITS.shortDescription
-      );
-      push("fullDescription", fullDescription, GOOGLE_PLAY_LIMITS.fullDescription);
-    }
-  }
-  return issues;
-}
 async function downloadScreenshotsToAsoDir(slug, asoData) {
   const rootDir = getPushDataDir();
   const productStoreRoot = path4.join(rootDir, "products", slug, "store");
@@ -893,10 +966,7 @@ Possible causes:
   }
   const storeData = prepareAsoDataForPush(slug, sanitizedData);
   const validationIssues = validateFieldLimits(sanitizedData);
-  const validationMessage = validationIssues.length > 0 ? `\u26A0\uFE0F Field limit issues (see ${FIELD_LIMITS_DOC_PATH}):
-- ${validationIssues.join(
-    "\n- "
-  )}` : `Field limits OK (checked against ${FIELD_LIMITS_DOC_PATH})`;
+  const validationMessage = formatValidationIssues(validationIssues);
   const pushDataRoot = getPushDataDir();
   if (dryRun) {
     return {
@@ -913,7 +983,9 @@ ${JSON.stringify(
 
 ${validationMessage}${sanitizeWarnings.length ? `
 Sanitized invalid characters:
-- ${sanitizeWarnings.join("\n- ")}` : ""}`
+- ${sanitizeWarnings.join(
+            "\n- "
+          )}` : ""}`
         }
       ]
     };
@@ -1530,6 +1602,19 @@ ${researchSections.join("\n")}
 
 `;
   prompt += `**Reference**: ${FIELD_LIMITS_DOC_PATH2}
+
+`;
+  prompt += `---
+
+`;
+  prompt += `## Next Step
+
+`;
+  prompt += `After saving the optimized JSON, proceed to **Stage 2** to optimize other locales:
+`;
+  prompt += `\`\`\`
+improve-public(slug="${slug}", stage="2", optimizedPrimary=<the JSON you just created>)
+\`\`\`
 `;
   return prompt;
 }
@@ -1603,17 +1688,30 @@ ${optimizedPrimary}
 \`\`\`
 
 `;
+  const { keywordResearchFallbackByLocale } = args;
+  const localesNeedingFallback = nonPrimaryLocales.filter((loc) => {
+    const fallbackInfo = keywordResearchFallbackByLocale?.[loc];
+    const researchSections = keywordResearchByLocale[loc] || [];
+    return researchSections.length === 0 || fallbackInfo?.isFallback;
+  });
   const primaryResearchSections = keywordResearchByLocale[primaryLocale] || [];
   const hasPrimaryResearch = primaryResearchSections.length > 0;
   prompt += `## Keyword Research (Per Locale)
 
+`;
+  prompt += `**Priority:** Use each locale's own keyword research. English fallback is ONLY used when locale-specific research is missing.
 `;
   prompt += `When both iOS and Android research exist for a locale, treat iOS keywords as primary; use Android keywords only if space remains after fitting iOS keywords within character limits.
 
 `;
-  if (hasPrimaryResearch) {
-    prompt += `**\u{1F4DA} ENGLISH (${primaryLocale}) Keywords - Use as fallback for locales without research (MUST TRANSLATE to target language):**
-${primaryResearchSections.join("\n")}
+  if (hasPrimaryResearch && localesNeedingFallback.length > 0) {
+    prompt += `---
+`;
+    prompt += `**\u{1F4DA} ENGLISH FALLBACK (${primaryLocale})** - Only for locales without their own research: ${localesNeedingFallback.join(
+      ", "
+    )}
+`;
+    prompt += `${primaryResearchSections.join("\n")}
 
 `;
     prompt += `---
@@ -1623,50 +1721,41 @@ ${primaryResearchSections.join("\n")}
   nonPrimaryLocales.forEach((loc) => {
     const researchSections = keywordResearchByLocale[loc] || [];
     const researchDir = keywordResearchDirByLocale[loc];
-    if (researchSections.length > 0) {
-      prompt += `### Locale ${loc}: \u2705 Saved research found
-${researchSections.join(
-        "\n"
-      )}
-
+    const fallbackInfo = keywordResearchFallbackByLocale?.[loc];
+    if (researchSections.length > 0 && !fallbackInfo?.isFallback) {
+      prompt += `### Locale ${loc}: \u2705 Using locale-specific keyword research
 `;
-    } else if (hasPrimaryResearch) {
-      prompt += `### Locale ${loc}: \u26A0\uFE0F No saved research - TRANSLATE ENGLISH KEYWORDS TO ${loc.toUpperCase()}
-`;
-      prompt += `No keyword research found at ${researchDir}.
-`;
-      prompt += `**CRITICAL FALLBACK STRATEGY:** You MUST translate English keywords from primary locale (${primaryLocale}) into ${loc}. DO NOT use English keywords directly.
+      prompt += researchSections.join("\n");
+      prompt += `
+**Use these ${loc} keywords directly** - they are already in the target language.
 
 `;
-      prompt += `**Translation Steps:**
-`;
-      prompt += `1. Take the Tier 1/2/3 keywords from English research above (${primaryLocale})
-`;
-      prompt += `2. **TRANSLATE each English keyword into ${loc}** - use natural, native expressions (NOT literal word-for-word translation)
+    } else if (researchSections.length > 0 && fallbackInfo?.isFallback) {
+      prompt += `### Locale ${loc}: \u{1F504} No ${loc} research found - Using ${fallbackInfo.fallbackLocale} as fallback
 `;
-      prompt += `3. Ensure translated keywords are what ${loc} users would actually search for in their language
+      prompt += researchSections.join("\n");
+      prompt += `
+**MUST TRANSLATE:** The keywords above are in ${fallbackInfo.fallbackLocale}. You MUST:
 `;
-      prompt += `4. Verify translations are culturally appropriate and contextually relevant
+      prompt += `1. **TRANSLATE each keyword into ${loc}** - use natural, native expressions
 `;
-      prompt += `5. Apply the **TRANSLATED** keywords (in ${loc} language) following the same tier strategy
+      prompt += `2. Ensure translated keywords are what ${loc} users would actually search for
 `;
-      prompt += `6. **DO NOT use English keywords in ${loc} locale** - all keywords must be in ${loc} language
+      prompt += `3. **DO NOT use ${fallbackInfo.fallbackLocale} keywords directly** - all keywords must be in ${loc} language
 
 `;
-    } else {
-      prompt += `### Locale ${loc}: \u26A0\uFE0F No research - TRANSLATE ENGLISH KEYWORDS FROM optimizedPrimary TO ${loc.toUpperCase()}
-`;
-      prompt += `No keyword research found. Extract keywords from the optimizedPrimary JSON above and **TRANSLATE them to ${loc}**:
-`;
-      prompt += `1. Extract keywords from \`aso.keywords\` in optimizedPrimary (these are in English/${primaryLocale})
+    } else if (hasPrimaryResearch) {
+      prompt += `### Locale ${loc}: \u26A0\uFE0F No research found - TRANSLATE from English fallback above
 `;
-      prompt += `2. **TRANSLATE each English keyword naturally into ${loc}** - use native search expressions
+      prompt += `No keyword research found at ${researchDir}.
 `;
-      prompt += `3. Ensure translated keywords match what ${loc} users would actually search for
+      prompt += `**Use the ENGLISH FALLBACK section above** and TRANSLATE all keywords to ${loc}.
+
 `;
-      prompt += `4. Apply the **TRANSLATED** keywords (in ${loc} language) to all ASO fields
+    } else {
+      prompt += `### Locale ${loc}: \u274C No research available
 `;
-      prompt += `5. **DO NOT use English keywords in ${loc} locale** - all keywords must be translated to ${loc}
+      prompt += `No keyword research found. Extract keywords from \`aso.keywords\` in optimizedPrimary and **TRANSLATE them to ${loc}**.
 
 `;
     }
@@ -1807,6 +1896,12 @@ ${researchSections.join(
 `;
     } else {
       prompt += `2. All batches completed! \u2705
+`;
+      prompt += `3. **Run validate-aso** to verify all locales:
+`;
+      prompt += `   \`\`\`
+   validate-aso(slug="${slug}")
+   \`\`\`
 
 `;
     }
@@ -1882,7 +1977,32 @@ ${researchSections.join(
   prompt += `Repeat for all locales in this batch: ${nonPrimaryLocales.join(
     ", "
   )}
+
+`;
+  const isLastBatch = batchIndex === void 0 || totalBatches && batchIndex + 1 >= totalBatches;
+  if (isLastBatch) {
+    prompt += `---
+
+`;
+    prompt += `## Final Step: Validate All Locales
+
+`;
+    prompt += `After completing ALL locale optimizations, run validation:
+`;
+    prompt += `\`\`\`
+validate-aso(slug="${slug}")
+\`\`\`
+
+`;
+    prompt += `This checks:
+`;
+    prompt += `- Field length limits (title \u226430, subtitle \u226430, keywords \u2264100, etc.)
+`;
+    prompt += `- Keyword duplicates
+`;
+    prompt += `- Invalid characters
 `;
+  }
   return prompt;
 }
 
@@ -2130,7 +2250,7 @@ function formatMergedData(merged, researchDir) {
   lines.push("\n----");
   return lines.join("\n");
 }
-function loadKeywordResearchForLocale(slug, locale) {
+function loadKeywordResearchForLocaleInternal(slug, locale) {
   const researchDir = path6.join(
     getKeywordResearchDir(),
     "products",
@@ -2139,9 +2259,12 @@ function loadKeywordResearchForLocale(slug, locale) {
     locale
   );
   if (!fs6.existsSync(researchDir)) {
-    return { entries: [], sections: [], researchDir };
+    return null;
   }
   const files = fs6.readdirSync(researchDir).filter((file) => file.endsWith(".json"));
+  if (files.length === 0) {
+    return null;
+  }
   const entries = [];
   for (const file of files) {
     const filePath = path6.join(researchDir, file);
@@ -2159,17 +2282,53 @@ function loadKeywordResearchForLocale(slug, locale) {
     }
   }
   const validEntries = entries.filter((e) => !e.data?.parseError);
+  if (validEntries.length === 0) {
+    return null;
+  }
   if (validEntries.length > 1) {
     const merged = mergeKeywordData(validEntries);
     const mergedSection = formatMergedData(merged, researchDir);
     return { entries, sections: [mergedSection], researchDir };
-  } else if (validEntries.length === 1) {
-    const sections2 = entries.map(formatEntry);
-    return { entries, sections: sections2, researchDir };
   }
   const sections = entries.map(formatEntry);
   return { entries, sections, researchDir };
 }
+var FALLBACK_LOCALES = ["en-US", "en"];
+function loadKeywordResearchForLocale(slug, locale) {
+  const researchDir = path6.join(
+    getKeywordResearchDir(),
+    "products",
+    slug,
+    "locales",
+    locale
+  );
+  const result = loadKeywordResearchForLocaleInternal(slug, locale);
+  if (result) {
+    return { ...result, isFallback: false };
+  }
+  for (const fallbackLocale of FALLBACK_LOCALES) {
+    if (fallbackLocale === locale) continue;
+    const fallbackResult = loadKeywordResearchForLocaleInternal(
+      slug,
+      fallbackLocale
+    );
+    if (fallbackResult) {
+      const fallbackNotice = `\u26A0\uFE0F **FALLBACK: Using ${fallbackLocale} keywords** - No research found for ${locale}. You MUST TRANSLATE these keywords to ${locale}.
+`;
+      const sectionsWithNotice = fallbackResult.sections.map(
+        (section) => fallbackNotice + section
+      );
+      return {
+        entries: fallbackResult.entries,
+        sections: sectionsWithNotice,
+        researchDir: fallbackResult.researchDir,
+        isFallback: true,
+        fallbackLocale
+      };
+    }
+  }
+  return { entries: [], sections: [], researchDir, isFallback: false };
+}
 
 // src/tools/improve-public.ts
 var toJsonSchema3 = zodToJsonSchema3;
@@ -2217,12 +2376,12 @@ This tool returns a PROMPT containing:
 
 ## STAGES
 - **Stage 1:** Primary locale optimization using saved keyword research (ios + android combined)
-- **Stage 2:** Localize to other languages using per-locale research OR translate English keywords
+- **Stage 2:** Localize to other languages - **each locale uses its OWN keyword research**
 
-## KEYWORD SOURCES
-- Uses SAVED keyword research from .aso/keywordResearch/products/[slug]/locales/
-- iOS and Android research are automatically combined (iOS prioritized; Android fills remaining slots when limits apply)
-- If locale research is missing, use English keywords and translate
+## KEYWORD SOURCES (Per Locale)
+- **Priority 1:** Uses each locale's SAVED keyword research from .aso/keywordResearch/products/[slug]/locales/[locale]/
+- **Priority 2 (Fallback):** If locale-specific research is missing, falls back to en-US/en keywords and TRANSLATES them
+- iOS and Android research are automatically combined per locale (iOS prioritized)
 
 **CRITICAL:** Only processes existing locale files. Does NOT create new files.`,
   inputSchema: inputSchema3
@@ -2279,10 +2438,15 @@ async function handleImprovePublic(input) {
   }
   const keywordResearchByLocale = {};
   const keywordResearchDirByLocale = {};
+  const keywordResearchFallbackByLocale = {};
   for (const loc of targetLocales) {
     const research = loadKeywordResearchForLocale(slug, loc);
     keywordResearchByLocale[loc] = research.sections;
     keywordResearchDirByLocale[loc] = research.researchDir;
+    keywordResearchFallbackByLocale[loc] = {
+      isFallback: research.isFallback,
+      fallbackLocale: research.fallbackLocale
+    };
   }
   const baseArgs = {
     slug,
@@ -2291,7 +2455,8 @@ async function handleImprovePublic(input) {
     targetLocales,
     localeSections,
     keywordResearchByLocale,
-    keywordResearchDirByLocale
+    keywordResearchDirByLocale,
+    keywordResearchFallbackByLocale
   };
   if (stage === "1" || stage === "both") {
     const prompt = generatePrimaryOptimizationPrompt(baseArgs);
@@ -2339,6 +2504,7 @@ async function handleImprovePublic(input) {
         localeSections: baseArgs.localeSections,
         keywordResearchByLocale: baseArgs.keywordResearchByLocale,
         keywordResearchDirByLocale: baseArgs.keywordResearchDirByLocale,
+        keywordResearchFallbackByLocale: baseArgs.keywordResearchFallbackByLocale,
         optimizedPrimary,
         batchLocales,
         batchIndex: currentBatchIndex,
@@ -3508,6 +3674,177 @@ Context around ${pos}: ${context}`
   };
 }
 
+// src/tools/validate-aso.ts
+import { z as z8 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema8 } from "zod-to-json-schema";
+var toJsonSchema5 = zodToJsonSchema8;
+var validateAsoInputSchema = z8.object({
+  slug: z8.string().describe("Product slug"),
+  locale: z8.string().optional().describe("Specific locale to validate (default: all locales)"),
+  fix: z8.boolean().optional().default(false).describe("Auto-fix issues where possible (e.g., remove invalid chars)")
+});
+var jsonSchema8 = toJsonSchema5(validateAsoInputSchema, {
+  name: "ValidateAsoInput",
+  $refStrategy: "none"
+});
+var inputSchema8 = jsonSchema8.definitions?.ValidateAsoInput || jsonSchema8;
+var validateAsoTool = {
+  name: "validate-aso",
+  description: `Validates ASO data against App Store / Google Play field limits and rules.
+
+**IMPORTANT:** Use 'search-app' tool first to resolve the exact slug.
+
+## WHAT IT VALIDATES
+1. **Field Length Limits** (${FIELD_LIMITS_DOC_PATH}):
+   - App Store: name \u2264${APP_STORE_LIMITS.name}, subtitle \u2264${APP_STORE_LIMITS.subtitle}, keywords \u2264${APP_STORE_LIMITS.keywords}, description \u2264${APP_STORE_LIMITS.description}
+   - Google Play: title \u2264${GOOGLE_PLAY_LIMITS.title}, shortDescription \u2264${GOOGLE_PLAY_LIMITS.shortDescription}, fullDescription \u2264${GOOGLE_PLAY_LIMITS.fullDescription}
+
+2. **Keyword Duplicates** (App Store only):
+   - Checks for duplicate keywords in comma-separated list
+
+3. **Invalid Characters**:
+   - Control characters, BOM, zero-width/invisible characters, variation selectors
+
+## WHEN TO USE
+- After running improve-public Stage 1/2 to verify optimization results
+- Before running public-to-aso to ensure data is valid
+- Anytime you want to check ASO data validity
+
+## OPTIONS
+- \`locale\`: Validate specific locale only (e.g., "ko-KR")
+- \`fix\`: Auto-fix issues where possible (removes invalid characters)`,
+  inputSchema: inputSchema8
+};
+function getLocaleStats(configData) {
+  const stats = [];
+  if (configData.appStore) {
+    const appStoreData = configData.appStore;
+    const locales = isAppStoreMultilingual(appStoreData) ? appStoreData.locales : { [appStoreData.locale || DEFAULT_LOCALE]: appStoreData };
+    for (const [locale, data] of Object.entries(locales)) {
+      const fields = [];
+      const checkField = (field, value, limit) => {
+        const length = value?.length || 0;
+        let status = "ok";
+        if (length > limit) status = "error";
+        else if (length > limit * 0.9) status = "warning";
+        fields.push({ field, length, limit, status });
+      };
+      checkField("name", data.name, APP_STORE_LIMITS.name);
+      checkField("subtitle", data.subtitle, APP_STORE_LIMITS.subtitle);
+      checkField("keywords", data.keywords, APP_STORE_LIMITS.keywords);
+      checkField("promotionalText", data.promotionalText, APP_STORE_LIMITS.promotionalText);
+      checkField("description", data.description, APP_STORE_LIMITS.description);
+      stats.push({ locale, store: "appStore", fields });
+    }
+  }
+  if (configData.googlePlay) {
+    const googlePlayData = configData.googlePlay;
+    const locales = isGooglePlayMultilingual(googlePlayData) ? googlePlayData.locales : { [googlePlayData.defaultLanguage || DEFAULT_LOCALE]: googlePlayData };
+    for (const [locale, data] of Object.entries(locales)) {
+      const fields = [];
+      const checkField = (field, value, limit) => {
+        const length = value?.length || 0;
+        let status = "ok";
+        if (length > limit) status = "error";
+        else if (length > limit * 0.9) status = "warning";
+        fields.push({ field, length, limit, status });
+      };
+      checkField("title", data.title, GOOGLE_PLAY_LIMITS.title);
+      checkField("shortDescription", data.shortDescription, GOOGLE_PLAY_LIMITS.shortDescription);
+      checkField("fullDescription", data.fullDescription, GOOGLE_PLAY_LIMITS.fullDescription);
+      stats.push({ locale, store: "googlePlay", fields });
+    }
+  }
+  return stats;
+}
+function formatStats(stats, filterLocale) {
+  const filteredStats = filterLocale ? stats.filter((s) => s.locale === filterLocale) : stats;
+  if (filteredStats.length === 0) {
+    return filterLocale ? `No data found for locale: ${filterLocale}` : "No ASO data found";
+  }
+  const lines = ["## Field Length Report\n"];
+  for (const stat of filteredStats) {
+    const storeLabel = stat.store === "appStore" ? "App Store" : "Google Play";
+    lines.push(`### ${storeLabel} [${stat.locale}]
+`);
+    lines.push("| Field | Length | Limit | Status |");
+    lines.push("|-------|--------|-------|--------|");
+    for (const field of stat.fields) {
+      const statusEmoji = field.status === "error" ? "\u274C" : field.status === "warning" ? "\u26A0\uFE0F" : "\u2705";
+      lines.push(
+        `| ${field.field} | ${field.length} | ${field.limit} | ${statusEmoji} |`
+      );
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function handleValidateAso(input) {
+  const { slug, locale, fix } = input;
+  const configData = loadAsoFromConfig(slug);
+  if (!configData.googlePlay && !configData.appStore) {
+    throw new Error(`No ASO data found for ${slug}`);
+  }
+  const results = [];
+  results.push(`# ASO Validation Report: ${slug}
+`);
+  const { sanitizedData, warnings: sanitizeWarnings } = sanitizeAsoData(configData);
+  if (sanitizeWarnings.length > 0) {
+    results.push(`## Invalid Characters Found
+`);
+    if (fix) {
+      results.push(
+        `The following invalid characters were ${fix ? "removed" : "detected"}:
+`
+      );
+    }
+    for (const warning of sanitizeWarnings) {
+      results.push(`- ${warning}`);
+    }
+    results.push("");
+  }
+  const dataToValidate = fix ? sanitizedData : configData;
+  const limitIssues = validateFieldLimits(dataToValidate);
+  const filteredIssues = locale ? limitIssues.filter((issue) => issue.locale === locale) : limitIssues;
+  results.push(formatValidationIssues(filteredIssues));
+  results.push("");
+  const keywordIssues = validateKeywords(dataToValidate);
+  const filteredKeywordIssues = locale ? keywordIssues.filter((issue) => issue.locale === locale) : keywordIssues;
+  if (filteredKeywordIssues.length > 0) {
+    results.push(`## Keyword Duplicates
+`);
+    for (const issue of filteredKeywordIssues) {
+      results.push(
+        `- [${issue.locale}]: ${issue.duplicates.join(", ")}`
+      );
+    }
+    results.push("");
+  }
+  const stats = getLocaleStats(dataToValidate);
+  results.push(formatStats(stats, locale));
+  const hasErrors = filteredIssues.length > 0 || filteredKeywordIssues.length > 0;
+  const hasSanitizeWarnings = sanitizeWarnings.length > 0;
+  results.push(`---
+`);
+  if (hasErrors) {
+    results.push(`\u274C **Validation failed** - Fix the issues above before pushing to stores.`);
+    results.push(`
+Reference: ${FIELD_LIMITS_DOC_PATH}`);
+  } else if (hasSanitizeWarnings && !fix) {
+    results.push(`\u26A0\uFE0F **Invalid characters detected** - Run with \`fix: true\` to auto-remove.`);
+  } else {
+    results.push(`\u2705 **Validation passed** - Ready to push to stores.`);
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: results.join("\n")
+      }
+    ]
+  };
+}
+
 // src/tools/index.ts
 var tools = [
   {
@@ -3565,6 +3902,14 @@ var tools = [
     zodSchema: searchAppInputSchema,
     handler: handleSearchApp,
     category: "App Management"
+  },
+  {
+    name: validateAsoTool.name,
+    description: validateAsoTool.description,
+    inputSchema: validateAsoTool.inputSchema,
+    zodSchema: validateAsoInputSchema,
+    handler: handleValidateAso,
+    category: "ASO Validation"
   }
 ];
 function getToolDefinitions() {
@@ -3575,7 +3920,8 @@ function getToolDefinitions() {
     initProjectTool,
     createBlogHtmlTool,
     keywordResearchTool,
-    searchAppTool
+    searchAppTool,
+    validateAsoTool
   ];
 }
 function getToolHandler(name) {

package/package.json

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