pabal-resource-mcp 1.4.8

package/dist/bin/mcp-server.js

@@ -0,0 +1,3994 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_APP_SLUG
+} from "../chunk-DLCIXAUB.js";
+import {
+  getKeywordResearchDir,
+  getProductsDir,
+  getPublicDir,
+  getPullDataDir,
+  getPushDataDir,
+  loadAsoFromConfig,
+  saveAsoToAsoDir
+} from "../chunk-W62HB2ZL.js";
+import {
+  DEFAULT_LOCALE,
+  appStoreToUnified,
+  googlePlayToUnified,
+  isAppStoreLocale,
+  isAppStoreMultilingual,
+  isGooglePlayLocale,
+  isGooglePlayMultilingual,
+  unifiedToAppStore,
+  unifiedToGooglePlay
+} from "../chunk-BOWRBVVV.js";
+
+// src/bin/mcp-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/aso/pull.ts
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// src/tools/aso/utils/pull/load-pull-data.util.ts
+import fs from "fs";
+import path from "path";
+function loadPullData(slug) {
+  const asoData = {};
+  const pullDataDir = getPullDataDir();
+  const googlePlayPath = path.join(
+    pullDataDir,
+    "products",
+    slug,
+    "store",
+    "google-play",
+    "aso-data.json"
+  );
+  if (fs.existsSync(googlePlayPath)) {
+    try {
+      const content = fs.readFileSync(googlePlayPath, "utf-8");
+      const data = JSON.parse(content);
+      if (data.googlePlay) {
+        asoData.googlePlay = data.googlePlay;
+      }
+    } catch (error) {
+      throw new Error(`Failed to read Google Play data: ${error}`);
+    }
+  }
+  const appStorePath = path.join(
+    pullDataDir,
+    "products",
+    slug,
+    "store",
+    "app-store",
+    "aso-data.json"
+  );
+  if (fs.existsSync(appStorePath)) {
+    try {
+      const content = fs.readFileSync(appStorePath, "utf-8");
+      const data = JSON.parse(content);
+      if (data.appStore) {
+        asoData.appStore = data.appStore;
+      }
+    } catch (error) {
+      throw new Error(`Failed to read App Store data: ${error}`);
+    }
+  }
+  return asoData;
+}
+
+// src/tools/aso/utils/pull/generate-conversion-prompt.util.ts
+function generateConversionPrompt(title, shortDescription, fullDescription, locale, keywords, promotionalText, googlePlayData, appStoreData, screenshotPaths) {
+  const inputData = {
+    locale
+  };
+  if (googlePlayData && appStoreData) {
+    inputData.mergedFrom = ["Google Play", "App Store"];
+    inputData.googlePlay = {
+      title: googlePlayData.title,
+      shortDescription: googlePlayData.shortDescription || null,
+      fullDescription: googlePlayData.fullDescription
+    };
+    inputData.appStore = {
+      name: appStoreData.name,
+      subtitle: appStoreData.subtitle || null,
+      description: appStoreData.description,
+      keywords: appStoreData.keywords || null,
+      promotionalText: appStoreData.promotionalText || null
+    };
+  } else if (googlePlayData) {
+    inputData.source = "Google Play";
+    inputData.title = googlePlayData.title;
+    inputData.shortDescription = googlePlayData.shortDescription || null;
+    inputData.fullDescription = googlePlayData.fullDescription;
+  } else if (appStoreData) {
+    inputData.source = "App Store";
+    inputData.title = appStoreData.name;
+    inputData.subtitle = appStoreData.subtitle || null;
+    inputData.fullDescription = appStoreData.description;
+    if (appStoreData.keywords) inputData.keywords = appStoreData.keywords;
+    if (appStoreData.promotionalText) inputData.promotionalText = appStoreData.promotionalText;
+  } else {
+    inputData.title = title;
+    inputData.shortDescription = shortDescription || null;
+    inputData.fullDescription = fullDescription;
+    if (keywords) inputData.keywords = keywords;
+    if (promotionalText) inputData.promotionalText = promotionalText;
+  }
+  const inputJson = JSON.stringify(inputData, null, 2);
+  const outputExample = {
+    aso: {
+      title: "App title",
+      subtitle: "Subtitle (App Store only, optional)",
+      shortDescription: "Short description (Google Play only, optional)",
+      keywords: ["keyword1", "keyword2"],
+      template: {
+        intro: "Brief app introduction paragraph (2-3 sentences)",
+        outro: "Closing paragraph and CTA (1-2 sentences)"
+      }
+    },
+    landing: {
+      screenshots: {
+        images: [
+          { title: "Caption title", description: "Caption body" }
+        ]
+      },
+      features: {
+        items: [{ title: "Feature title", body: "Feature description" }]
+      }
+    }
+  };
+  const outputFormatJson = JSON.stringify(outputExample, null, 2);
+  const hasBothPlatforms = googlePlayData && appStoreData;
+  return `Please convert the following store ASO data into config.json format.
+
+**Input Data:**
+\`\`\`json
+${inputJson}
+\`\`\`
+
+**Output Format:**
+Convert according to the following JSON schema:
+
+\`\`\`json
+${outputFormatJson}
+\`\`\`
+
+**Conversion Rules:**
+${hasBothPlatforms ? `
+**IMPORTANT - Data Merge Strategy:**
+This locale has data from BOTH Google Play and App Store. Use the following merge strategy:
+- **Title/Name**: Prefer App Store name if available, otherwise use Google Play title
+- **Subtitle/Short Description**: Use App Store subtitle if available, otherwise use Google Play shortDescription
+- **Full Description**: Merge both descriptions intelligently:
+  - If descriptions are similar, use the more detailed version
+  - If descriptions are different, combine unique information from both
+  - Prioritize App Store description for intro/outro (usually more polished)
+  - Incorporate unique features from Google Play description
+- **Keywords**: Use App Store keywords (Google Play doesn't have explicit keywords field)
+- **Promotional Text**: Use App Store promotionalText if available
+
+**Content Extraction:**
+` : ""}1. Use the first paragraph(s) of fullDescription as template.intro (2-3 sentences).
+2. Use the final paragraph as template.outro (1-2 sentences, keep CTA tone).
+3. Extract the strongest bullets/sections from the body into landing.features.items (3-5 items). Each item should have title + 1-2 sentence body.
+4. Extract any explicit bullet lists or section highlights into landing.screenshots.images captions (keep order; 3-5 entries). Each needs title + short description.
+5. Convert comma-separated keywords string to array.
+6. Include Contact & Support info only if present in the original text; otherwise omit.
+
+**Translation Guidelines (if converting to non-English locales):**
+- Keep proper nouns and technical terms in English when translating
+- Keep terms like "Always-On Display", "E-Ink", "Android", brand names (e.g., "Boox", "Meebook"), and other technical/proper nouns in English
+- Only translate descriptive text, not technical terminology or proper nouns
+- Example: "Always-On Display" should remain "Always-On Display" in Korean, not translated to "\uD56D\uC0C1 \uCF1C\uC9C4 \uD654\uBA74"
+
+${screenshotPaths ? `
+**Screenshot Paths:**
+Screenshots for this locale can be found at:
+${screenshotPaths.googlePlay ? `- Google Play: ${screenshotPaths.googlePlay}` : ""}
+${screenshotPaths.appStore ? `- App Store: ${screenshotPaths.appStore}` : ""}
+
+Copy screenshots from these directories to public/products/[slug]/screenshots/ as needed.
+` : ""}
+**Important:** Return only valid JSON, without any additional explanation.`;
+}
+
+// src/tools/aso/pull.ts
+var toJsonSchema = zodToJsonSchema;
+var asoToPublicInputSchema = z.object({
+  slug: z.string().describe("Product slug")
+});
+var jsonSchema = toJsonSchema(asoToPublicInputSchema, {
+  name: "AsoToPublicInput",
+  $refStrategy: "none"
+});
+var inputSchema = jsonSchema.definitions?.AsoToPublicInput || jsonSchema;
+var asoToPublicTool = {
+  name: "aso-to-public",
+  description: `Converts ASO data from pullData to public/products/[slug]/ structure.
+
+**IMPORTANT:** Always use 'search-app' tool first to resolve the exact slug before calling this tool. The user may provide an approximate name, bundleId, or packageName - search-app will find and return the correct slug. Never pass user input directly as slug.
+
+This tool:
+1. Loads ASO data from .aso/pullData/products/[slug]/store/ (path from ~/.config/pabal-mcp/config.json dataDir)
+2. Generates per-locale conversion prompts to map fullDescription into structured locale JSON (template intro/outro + landing features/screenshots captions)
+3. Next steps (manual): paste converted JSON into public/products/[slug]/locales/[locale].json and copy screenshots from .aso/pullData if needed
+
+The conversion from unstructured to structured format is performed by Claude based on the conversion prompt.`,
+  inputSchema
+};
+async function handleAsoToPublic(input) {
+  const { slug } = input;
+  const asoData = loadPullData(slug);
+  if (!asoData.googlePlay && !asoData.appStore) {
+    throw new Error(`No ASO data found in pullData for ${slug}`);
+  }
+  const mergedDataByLocale = /* @__PURE__ */ new Map();
+  if (asoData.googlePlay) {
+    const googlePlayData = asoData.googlePlay;
+    const locales = isGooglePlayMultilingual(googlePlayData) ? googlePlayData.locales : {
+      [googlePlayData.defaultLanguage || DEFAULT_LOCALE]: googlePlayData
+    };
+    for (const [platformLocale, localeData] of Object.entries(locales)) {
+      const unifiedLocale = googlePlayToUnified(platformLocale);
+      if (!mergedDataByLocale.has(unifiedLocale)) {
+        mergedDataByLocale.set(unifiedLocale, { unifiedLocale });
+      }
+      const merged = mergedDataByLocale.get(unifiedLocale);
+      merged.googlePlay = {
+        title: localeData.title,
+        shortDescription: localeData.shortDescription,
+        fullDescription: localeData.fullDescription
+      };
+    }
+  }
+  if (asoData.appStore) {
+    const appStoreData = asoData.appStore;
+    const locales = isAppStoreMultilingual(appStoreData) ? appStoreData.locales : { [appStoreData.locale || DEFAULT_LOCALE]: appStoreData };
+    for (const [platformLocale, localeData] of Object.entries(locales)) {
+      const unifiedLocale = appStoreToUnified(platformLocale);
+      if (!mergedDataByLocale.has(unifiedLocale)) {
+        mergedDataByLocale.set(unifiedLocale, { unifiedLocale });
+      }
+      const merged = mergedDataByLocale.get(unifiedLocale);
+      merged.appStore = {
+        name: localeData.name,
+        subtitle: localeData.subtitle,
+        description: localeData.description,
+        keywords: localeData.keywords,
+        promotionalText: localeData.promotionalText
+      };
+    }
+  }
+  const conversionPrompts = [];
+  const conversionTasks = [];
+  for (const [unifiedLocale, mergedData] of mergedDataByLocale.entries()) {
+    const sources = [];
+    if (mergedData.googlePlay) sources.push("Google Play");
+    if (mergedData.appStore) sources.push("App Store");
+    let screenshotPaths;
+    if (mergedData.googlePlay) {
+      const googlePlayLocale = Object.keys(
+        isGooglePlayMultilingual(asoData.googlePlay) ? asoData.googlePlay.locales : { [asoData.googlePlay.defaultLanguage || DEFAULT_LOCALE]: {} }
+      ).find((loc) => googlePlayToUnified(loc) === unifiedLocale);
+      if (googlePlayLocale) {
+        if (!screenshotPaths) screenshotPaths = {};
+        const pullDataDir2 = getPullDataDir();
+        screenshotPaths.googlePlay = `${pullDataDir2}/products/${slug}/store/google-play/screenshots/${googlePlayLocale}/`;
+      }
+    }
+    if (mergedData.appStore) {
+      const appStoreLocale = Object.keys(
+        isAppStoreMultilingual(asoData.appStore) ? asoData.appStore.locales : { [asoData.appStore.locale || DEFAULT_LOCALE]: {} }
+      ).find((loc) => appStoreToUnified(loc) === unifiedLocale);
+      if (appStoreLocale) {
+        if (!screenshotPaths) screenshotPaths = {};
+        const pullDataDir2 = getPullDataDir();
+        screenshotPaths.appStore = `${pullDataDir2}/products/${slug}/store/app-store/screenshots/${appStoreLocale}/`;
+      }
+    }
+    const prompt = generateConversionPrompt(
+      mergedData.googlePlay?.title || mergedData.appStore?.name || "",
+      mergedData.googlePlay?.shortDescription || mergedData.appStore?.subtitle,
+      mergedData.googlePlay?.fullDescription || mergedData.appStore?.description || "",
+      unifiedLocale,
+      mergedData.appStore?.keywords,
+      mergedData.appStore?.promotionalText,
+      mergedData.googlePlay,
+      mergedData.appStore,
+      screenshotPaths
+    );
+    conversionTasks.push({
+      locale: unifiedLocale,
+      sources,
+      prompt
+    });
+    const sourcesText = sources.join(" + ");
+    conversionPrompts.push(
+      `
+--- ${unifiedLocale} (${sourcesText}) ---
+${prompt}`
+    );
+  }
+  const pullDataDir = getPullDataDir();
+  let responseText = `Converting ASO data from pullData to public/products/${slug}/ structure.
+
+`;
+  responseText += `Found ${conversionTasks.length} unified locale(s) to convert.
+`;
+  responseText += `Data sources: Google Play (${asoData.googlePlay ? "\u2713" : "\u2717"}), App Store (${asoData.appStore ? "\u2713" : "\u2717"})
+
+`;
+  responseText += "Please convert each locale's ASO data using the prompts below.\n";
+  responseText += "When both platforms have data for the same locale, they are merged into a single conversion.\n\n";
+  responseText += conversionPrompts.join("\n\n");
+  responseText += `
+
+Next steps (manual):
+`;
+  responseText += `1. Save converted JSON to public/products/${slug}/locales/[locale].json
+`;
+  responseText += `   Example: public/products/${slug}/locales/ar.json (not ar-SA.json)
+`;
+  responseText += `2. Copy screenshots from ${pullDataDir}/products/${slug}/store/ to public/products/${slug}/screenshots/
+`;
+  return {
+    content: [
+      {
+        type: "text",
+        text: responseText
+      }
+    ]
+  };
+}
+
+// src/tools/aso/push.ts
+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/aso/utils/push/prepare-aso-data-for-push.util.ts
+function prepareAsoDataForPush(slug, configData) {
+  const storeData = {};
+  const baseUrl = process.env.NEXT_PUBLIC_SITE_URL ?? "https://labs.quartz.best";
+  const detailPageUrl = `${baseUrl}/${slug}`;
+  if (configData.googlePlay) {
+    const googlePlayData = configData.googlePlay;
+    const locales = isGooglePlayMultilingual(googlePlayData) ? googlePlayData.locales : {
+      [googlePlayData.defaultLanguage || DEFAULT_LOCALE]: googlePlayData
+    };
+    const cleanedLocales = {};
+    for (const [locale, localeData] of Object.entries(locales)) {
+      const { screenshots, ...rest } = localeData;
+      cleanedLocales[locale] = {
+        ...rest,
+        featureGraphic: void 0,
+        // Images excluded
+        contactWebsite: detailPageUrl
+        // Set detail page URL
+      };
+    }
+    const convertedLocales = {};
+    for (const [unifiedLocale, localeData] of Object.entries(cleanedLocales)) {
+      const googlePlayLocale = unifiedToGooglePlay(
+        unifiedLocale
+      );
+      if (googlePlayLocale !== null) {
+        convertedLocales[googlePlayLocale] = {
+          ...localeData,
+          defaultLanguage: googlePlayLocale
+        };
+      }
+    }
+    const googleDefaultLocale = isGooglePlayMultilingual(googlePlayData) ? googlePlayData.defaultLocale || DEFAULT_LOCALE : googlePlayData.defaultLanguage || DEFAULT_LOCALE;
+    const convertedDefaultLocale = unifiedToGooglePlay(googleDefaultLocale) || googleDefaultLocale;
+    storeData.googlePlay = {
+      locales: convertedLocales,
+      defaultLocale: convertedDefaultLocale
+    };
+  }
+  if (configData.appStore) {
+    const appStoreData = configData.appStore;
+    const locales = isAppStoreMultilingual(appStoreData) ? appStoreData.locales : { [appStoreData.locale || DEFAULT_LOCALE]: appStoreData };
+    const cleanedLocales = {};
+    for (const [locale, localeData] of Object.entries(locales)) {
+      const { screenshots, ...rest } = localeData;
+      cleanedLocales[locale] = {
+        ...rest,
+        marketingUrl: detailPageUrl
+        // Set detail page URL
+      };
+    }
+    const convertedLocales = {};
+    for (const [unifiedLocale, localeData] of Object.entries(cleanedLocales)) {
+      const appStoreLocale = unifiedToAppStore(unifiedLocale);
+      if (appStoreLocale !== null) {
+        convertedLocales[appStoreLocale] = {
+          ...localeData,
+          locale: appStoreLocale
+        };
+      }
+    }
+    const appStoreDefaultLocale = isAppStoreMultilingual(appStoreData) ? appStoreData.defaultLocale || DEFAULT_LOCALE : appStoreData.locale || DEFAULT_LOCALE;
+    const convertedDefaultLocale = unifiedToAppStore(appStoreDefaultLocale) || appStoreDefaultLocale;
+    storeData.appStore = {
+      locales: convertedLocales,
+      defaultLocale: convertedDefaultLocale
+    };
+  }
+  return storeData;
+}
+
+// src/tools/aso/utils/push/save-raw-aso-data.util.ts
+function saveRawAsoData(slug, asoData) {
+  const rootDir = getPushDataDir();
+  saveAsoToAsoDir(slug, asoData);
+  const localeCounts = {};
+  if (asoData.googlePlay) {
+    const googlePlayData = asoData.googlePlay;
+    const locales = isGooglePlayMultilingual(googlePlayData) ? googlePlayData.locales : { [googlePlayData.defaultLanguage || DEFAULT_LOCALE]: googlePlayData };
+    localeCounts.googlePlay = Object.keys(locales).length;
+  }
+  if (asoData.appStore) {
+    const appStoreData = asoData.appStore;
+    const locales = isAppStoreMultilingual(appStoreData) ? appStoreData.locales : { [appStoreData.locale || DEFAULT_LOCALE]: appStoreData };
+    localeCounts.appStore = Object.keys(locales).length;
+  }
+  if (localeCounts.googlePlay) {
+    console.log(
+      `\u{1F4BE} Google Play raw data saved to ${rootDir} (${localeCounts.googlePlay} locale${localeCounts.googlePlay > 1 ? "s" : ""})`
+    );
+  }
+  if (localeCounts.appStore) {
+    console.log(
+      `\u{1F4BE} App Store raw data saved to ${rootDir} (${localeCounts.appStore} locale${localeCounts.appStore > 1 ? "s" : ""})`
+    );
+  }
+}
+
+// src/tools/aso/utils/push/download-image.util.ts
+import fs2 from "fs";
+import path2 from "path";
+async function downloadImage(url, outputPath) {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(
+        `Image download failed: ${response.status} ${response.statusText}`
+      );
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    const dir = path2.dirname(outputPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    fs2.writeFileSync(outputPath, buffer);
+  } catch (error) {
+    console.error(`\u274C Image download failed (${url}):`, error);
+    throw error;
+  }
+}
+
+// src/tools/aso/utils/push/is-local-asset-path.util.ts
+function isLocalAssetPath(assetPath) {
+  if (!assetPath) {
+    return false;
+  }
+  const trimmedPath = assetPath.trim();
+  return !/^([a-z]+:)?\/\//i.test(trimmedPath);
+}
+
+// src/tools/aso/utils/push/copy-local-asset-to-aso-dir.util.ts
+import fs3 from "fs";
+import path3 from "path";
+function copyLocalAssetToAsoDir(assetPath, outputPath) {
+  const publicDir = getPublicDir();
+  const trimmedPath = assetPath.replace(/^\.\//, "").replace(/^public\//, "").replace(/^\/+/, "");
+  const sourcePath = path3.join(publicDir, trimmedPath);
+  if (!fs3.existsSync(sourcePath)) {
+    console.warn(`\u26A0\uFE0F  Local image not found: ${sourcePath}`);
+    return false;
+  }
+  const dir = path3.dirname(outputPath);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  fs3.copyFileSync(sourcePath, outputPath);
+  return true;
+}
+
+// src/tools/utils/shared/convert-to-multilingual.util.ts
+function convertToMultilingual(data, locale) {
+  const detectedLocale = locale || data.locale || data.defaultLanguage || DEFAULT_LOCALE;
+  return {
+    locales: {
+      [detectedLocale]: data
+    },
+    defaultLocale: detectedLocale
+  };
+}
+
+// src/tools/aso/push.ts
+import fs4 from "fs";
+var toJsonSchema2 = zodToJsonSchema2;
+var publicToAsoInputSchema = z2.object({
+  slug: z2.string().describe("Product slug"),
+  dryRun: z2.boolean().optional().default(false).describe("Preview mode (no changes)")
+});
+var jsonSchema2 = toJsonSchema2(publicToAsoInputSchema, {
+  name: "PublicToAsoInput",
+  $refStrategy: "none"
+});
+var inputSchema2 = jsonSchema2.definitions?.PublicToAsoInput || jsonSchema2;
+async function downloadScreenshotsToAsoDir(slug, asoData) {
+  const rootDir = getPushDataDir();
+  const productStoreRoot = path4.join(rootDir, "products", slug, "store");
+  if (asoData.googlePlay) {
+    let googlePlayData = asoData.googlePlay;
+    if (!isGooglePlayMultilingual(googlePlayData)) {
+      googlePlayData = convertToMultilingual(
+        googlePlayData,
+        googlePlayData.defaultLanguage
+      );
+    }
+    for (const unifiedLocale of Object.keys(googlePlayData.locales)) {
+      const googlePlayLocale = unifiedToGooglePlay(
+        unifiedLocale
+      );
+      if (!googlePlayLocale) {
+        continue;
+      }
+      const localeData = googlePlayData.locales[unifiedLocale];
+      const asoDir = path4.join(
+        productStoreRoot,
+        "google-play",
+        "screenshots",
+        googlePlayLocale
+      );
+      const phoneScreenshots = localeData.screenshots?.phone;
+      if (phoneScreenshots && phoneScreenshots.length > 0) {
+        for (let i = 0; i < phoneScreenshots.length; i++) {
+          const url = phoneScreenshots[i];
+          const filename = `phone-${i + 1}.png`;
+          const outputPath = path4.join(asoDir, filename);
+          if (isLocalAssetPath(url)) {
+            copyLocalAssetToAsoDir(url, outputPath);
+            continue;
+          }
+          await downloadImage(url, outputPath);
+        }
+      }
+      const tablet7Screenshots = localeData.screenshots?.tablet7;
+      if (tablet7Screenshots && tablet7Screenshots.length > 0) {
+        for (let i = 0; i < tablet7Screenshots.length; i++) {
+          const url = tablet7Screenshots[i];
+          const filename = `tablet7-${i + 1}.png`;
+          const outputPath = path4.join(asoDir, filename);
+          if (isLocalAssetPath(url)) {
+            copyLocalAssetToAsoDir(url, outputPath);
+            continue;
+          }
+          await downloadImage(url, outputPath);
+        }
+      }
+      const tablet10Screenshots = localeData.screenshots?.tablet10;
+      if (tablet10Screenshots && tablet10Screenshots.length > 0) {
+        for (let i = 0; i < tablet10Screenshots.length; i++) {
+          const url = tablet10Screenshots[i];
+          const filename = `tablet10-${i + 1}.png`;
+          const outputPath = path4.join(asoDir, filename);
+          if (isLocalAssetPath(url)) {
+            copyLocalAssetToAsoDir(url, outputPath);
+            continue;
+          }
+          await downloadImage(url, outputPath);
+        }
+      }
+      const tabletScreenshots = localeData.screenshots?.tablet;
+      if (tabletScreenshots && tabletScreenshots.length > 0) {
+        for (let i = 0; i < tabletScreenshots.length; i++) {
+          const url = tabletScreenshots[i];
+          const filename = `tablet-${i + 1}.png`;
+          const outputPath = path4.join(asoDir, filename);
+          if (isLocalAssetPath(url)) {
+            copyLocalAssetToAsoDir(url, outputPath);
+            continue;
+          }
+          await downloadImage(url, outputPath);
+        }
+      }
+      if (localeData.featureGraphic) {
+        const featureGraphicUrl = localeData.featureGraphic;
+        const outputPath = path4.join(asoDir, "feature-graphic.png");
+        if (isLocalAssetPath(featureGraphicUrl)) {
+          copyLocalAssetToAsoDir(featureGraphicUrl, outputPath);
+        } else {
+          await downloadImage(featureGraphicUrl, outputPath);
+        }
+      }
+    }
+  }
+  if (asoData.appStore) {
+    let appStoreData = asoData.appStore;
+    if (!isAppStoreMultilingual(appStoreData)) {
+      appStoreData = convertToMultilingual(appStoreData, appStoreData.locale);
+    }
+    for (const unifiedLocale of Object.keys(appStoreData.locales)) {
+      const appStoreLocale = unifiedToAppStore(unifiedLocale);
+      if (!appStoreLocale) {
+        continue;
+      }
+      const localeData = appStoreData.locales[unifiedLocale];
+      const asoDir = path4.join(
+        productStoreRoot,
+        "app-store",
+        "screenshots",
+        appStoreLocale
+      );
+      const iphone65Screenshots = localeData.screenshots?.iphone65;
+      if (iphone65Screenshots && iphone65Screenshots.length > 0) {
+        for (let i = 0; i < iphone65Screenshots.length; i++) {
+          const url = iphone65Screenshots[i];
+          const filename = `iphone65-${i + 1}.png`;
+          const outputPath = path4.join(asoDir, filename);
+          if (isLocalAssetPath(url)) {
+            copyLocalAssetToAsoDir(url, outputPath);
+            continue;
+          }
+          await downloadImage(url, outputPath);
+        }
+      }
+      const ipadPro129Screenshots = localeData.screenshots?.ipadPro129;
+      if (ipadPro129Screenshots && ipadPro129Screenshots.length > 0) {
+        for (let i = 0; i < ipadPro129Screenshots.length; i++) {
+          const url = ipadPro129Screenshots[i];
+          const filename = `ipadPro129-${i + 1}.png`;
+          const outputPath = path4.join(asoDir, filename);
+          if (isLocalAssetPath(url)) {
+            copyLocalAssetToAsoDir(url, outputPath);
+            continue;
+          }
+          await downloadImage(url, outputPath);
+        }
+      }
+    }
+  }
+}
+var publicToAsoTool = {
+  name: "public-to-aso",
+  description: `Prepares ASO data from public/products/[slug]/ to pushData format.
+
+**IMPORTANT:** Always use 'search-app' tool first to resolve the exact slug before calling this tool. The user may provide an approximate name, bundleId, or packageName - search-app will find and return the correct slug. Never pass user input directly as slug.
+
+This tool:
+1. Loads ASO data from public/products/[slug]/config.json + locales/
+2. Converts to store-compatible format (removes screenshots from metadata, sets contactWebsite/marketingUrl)
+3. Saves metadata to .aso/pushData/products/[slug]/store/ (path from ~/.config/pabal-mcp/config.json dataDir)
+4. Copies/downloads screenshots to .aso/pushData/products/[slug]/store/screenshots/
+5. Validates text field lengths against ${FIELD_LIMITS_DOC_PATH} (fails if over limits)
+
+Before running, review ${FIELD_LIMITS_DOC_PATH} for per-store limits. This prepares data for pushing to stores without actually uploading.`,
+  inputSchema: inputSchema2
+};
+async function handlePublicToAso(input) {
+  const { slug, dryRun } = input;
+  const configData = loadAsoFromConfig(slug);
+  const { sanitizedData, warnings: sanitizeWarnings } = sanitizeAsoData(configData);
+  if (!sanitizedData.googlePlay && !sanitizedData.appStore) {
+    const productsDir = getProductsDir();
+    const configPath = path4.join(productsDir, slug, "config.json");
+    const localesDir = path4.join(productsDir, slug, "locales");
+    const errors = [];
+    if (!fs4.existsSync(configPath)) {
+      errors.push(`- config.json not found at ${configPath}`);
+    } else {
+      try {
+        const config = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
+        if (!config.packageName && !config.bundleId) {
+          errors.push(
+            `- config.json exists but missing both packageName and bundleId`
+          );
+        } else {
+          if (config.packageName) {
+            errors.push(`- packageName found: ${config.packageName}`);
+          }
+          if (config.bundleId) {
+            errors.push(`- bundleId found: ${config.bundleId}`);
+          }
+        }
+      } catch (e) {
+        errors.push(
+          `- Failed to parse config.json: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
+    if (!fs4.existsSync(localesDir)) {
+      errors.push(`- locales directory not found at ${localesDir}`);
+    } else {
+      try {
+        const localeFiles = fs4.readdirSync(localesDir).filter((f) => f.endsWith(".json"));
+        if (localeFiles.length === 0) {
+          errors.push(`- locales directory exists but no .json files found`);
+        } else {
+          errors.push(
+            `- Found ${localeFiles.length} locale file(s): ${localeFiles.join(
+              ", "
+            )}`
+          );
+          const validLocales = [];
+          const invalidLocales = [];
+          for (const file of localeFiles) {
+            const localeCode = file.replace(".json", "");
+            if (isGooglePlayLocale(localeCode) || isAppStoreLocale(localeCode)) {
+              validLocales.push(localeCode);
+            } else {
+              invalidLocales.push(localeCode);
+            }
+          }
+          if (validLocales.length > 0) {
+            errors.push(`- Valid locales: ${validLocales.join(", ")}`);
+          }
+          if (invalidLocales.length > 0) {
+            errors.push(
+              `- Invalid locales (not supported by Google Play or App Store): ${invalidLocales.join(
+                ", "
+              )}`
+            );
+          }
+        }
+      } catch (e) {
+        errors.push(
+          `- Failed to read locales directory: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
+    throw new Error(
+      `No ASO data found in config.json + locales/ for ${slug}
+
+Diagnostics:
+${errors.join("\n")}
+
+Possible causes:
+1. config.json is missing packageName (for Google Play) or bundleId (for App Store)
+2. locales/ directory is missing or empty
+3. Locale files exist but don't match supported Google Play/App Store locales
+4. Locale files don't contain valid ASO data`
+    );
+  }
+  const storeData = prepareAsoDataForPush(slug, sanitizedData);
+  const validationIssues = validateFieldLimits(sanitizedData);
+  const validationMessage = formatValidationIssues(validationIssues);
+  const pushDataRoot = getPushDataDir();
+  if (dryRun) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Preview mode - Data that would be saved to ${pushDataRoot}:
+
+${JSON.stringify(
+            storeData,
+            null,
+            2
+          )}
+
+${validationMessage}${sanitizeWarnings.length ? `
+Sanitized invalid characters:
+- ${sanitizeWarnings.join(
+            "\n- "
+          )}` : ""}`
+        }
+      ]
+    };
+  }
+  if (validationIssues.length > 0) {
+    throw new Error(
+      `Field limit violations detected. Fix before pushing.
+${validationMessage}`
+    );
+  }
+  saveRawAsoData(slug, storeData);
+  await downloadScreenshotsToAsoDir(slug, configData);
+  const localeCounts = {};
+  if (storeData.googlePlay) {
+    const googlePlayData = storeData.googlePlay;
+    const locales = isGooglePlayMultilingual(googlePlayData) ? googlePlayData.locales : {
+      [googlePlayData.defaultLanguage || DEFAULT_LOCALE]: googlePlayData
+    };
+    localeCounts.googlePlay = Object.keys(locales).length;
+  }
+  if (storeData.appStore) {
+    const appStoreData = storeData.appStore;
+    const locales = isAppStoreMultilingual(appStoreData) ? appStoreData.locales : { [appStoreData.locale || DEFAULT_LOCALE]: appStoreData };
+    localeCounts.appStore = Object.keys(locales).length;
+  }
+  let responseText = `\u2705 ${slug} pushData files prepared from config.json + locales/ (images + metadata synced)
+
+`;
+  if (localeCounts.googlePlay) {
+    responseText += `Google Play: ${localeCounts.googlePlay} locale(s)
+`;
+  }
+  if (localeCounts.appStore) {
+    responseText += `App Store: ${localeCounts.appStore} locale(s)
+`;
+  }
+  responseText += `
+Next step: Push to stores using pabal-mcp's aso-push tool`;
+  responseText += `
+Reference: ${FIELD_LIMITS_DOC_PATH}`;
+  if (sanitizeWarnings.length > 0) {
+    responseText += `
+Sanitized invalid characters:
+- ${sanitizeWarnings.join(
+      "\n- "
+    )}`;
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: responseText
+      }
+    ]
+  };
+}
+
+// src/tools/aso/improve.ts
+import { z as z3 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema3 } from "zod-to-json-schema";
+
+// src/tools/aso/utils/improve/load-product-locales.util.ts
+import fs5 from "fs";
+import path5 from "path";
+function loadProductLocales(slug) {
+  const productsDir = getProductsDir();
+  const productDir = path5.join(productsDir, slug);
+  const configPath = path5.join(productDir, "config.json");
+  const localesDir = path5.join(productDir, "locales");
+  let config = null;
+  if (fs5.existsSync(configPath)) {
+    const raw = fs5.readFileSync(configPath, "utf-8");
+    config = JSON.parse(raw);
+  }
+  if (!fs5.existsSync(localesDir)) {
+    throw new Error(`No locales directory found for ${slug}`);
+  }
+  const locales = {};
+  const localeFiles = fs5.readdirSync(localesDir).filter((file) => file.endsWith(".json"));
+  if (localeFiles.length === 0) {
+    throw new Error(`No locale files found for ${slug}`);
+  }
+  for (const file of localeFiles) {
+    const localeCode = file.replace(".json", "");
+    const localePath = path5.join(localesDir, file);
+    const content = fs5.readFileSync(localePath, "utf-8");
+    locales[localeCode] = JSON.parse(content);
+  }
+  return { config, locales };
+}
+function resolvePrimaryLocale(config, locales) {
+  const localeKeys = Object.keys(locales);
+  if (localeKeys.length === 0) {
+    return DEFAULT_LOCALE;
+  }
+  const configuredDefault = config?.content?.defaultLocale;
+  if (configuredDefault && locales[configuredDefault]) {
+    return configuredDefault;
+  }
+  if (locales[DEFAULT_LOCALE]) {
+    return DEFAULT_LOCALE;
+  }
+  return localeKeys[0];
+}
+
+// src/tools/aso/utils/improve/get-full-description.util.ts
+function getFullDescriptionForLocale(asoData, locale) {
+  if (asoData.googlePlay) {
+    const googlePlayData = asoData.googlePlay;
+    if (isGooglePlayMultilingual(googlePlayData)) {
+      const localeData = googlePlayData.locales[locale];
+      if (localeData?.fullDescription) {
+        return localeData.fullDescription;
+      }
+    } else if (googlePlayData.defaultLanguage === locale) {
+      return googlePlayData.fullDescription;
+    }
+  }
+  if (asoData.appStore) {
+    const appStoreData = asoData.appStore;
+    if (isAppStoreMultilingual(appStoreData)) {
+      const localeData = appStoreData.locales[locale];
+      if (localeData?.description) {
+        return localeData.description;
+      }
+    } else if (appStoreData.locale === locale) {
+      return appStoreData.description;
+    }
+  }
+  return void 0;
+}
+
+// src/tools/aso/utils/improve/keyword-analysis.util.ts
+function analyzeKeywords(content) {
+  const words = content.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((word) => word.length > 2);
+  const frequency = {};
+  for (const word of words) {
+    frequency[word] = (frequency[word] || 0) + 1;
+  }
+  const totalWords = words.length;
+  const density = {};
+  for (const [word, count] of Object.entries(frequency)) {
+    density[word] = count / totalWords * 100;
+  }
+  return { keywordFrequency: frequency, keywordDensity: density, totalWords };
+}
+function extractKeywordsFromContent(localeData) {
+  const keywords = /* @__PURE__ */ new Set();
+  const aso = localeData.aso || {};
+  const landing = localeData.landing || {};
+  if (Array.isArray(aso.keywords)) {
+    aso.keywords.forEach((kw) => keywords.add(kw.toLowerCase()));
+  } else if (typeof aso.keywords === "string") {
+    aso.keywords.split(",").map((kw) => kw.trim().toLowerCase()).forEach((kw) => keywords.add(kw));
+  }
+  [aso.title, aso.subtitle, aso.shortDescription].forEach((text) => {
+    if (text) {
+      text.toLowerCase().split(/\s+/).filter((word) => word.length > 2).forEach((word) => keywords.add(word));
+    }
+  });
+  if (aso.template?.intro) {
+    aso.template.intro.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((word) => word.length > 3).forEach((word) => keywords.add(word));
+  }
+  if (aso.template?.outro) {
+    aso.template.outro.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((word) => word.length > 3).forEach((word) => keywords.add(word));
+  }
+  const hero = landing.hero || {};
+  [hero.title, hero.description].forEach((text) => {
+    if (text) {
+      text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((word) => word.length > 3).forEach((word) => keywords.add(word));
+    }
+  });
+  const features = landing.features?.items || [];
+  features.forEach((feature) => {
+    if (feature.title) {
+      feature.title.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((word) => word.length > 3).forEach((word) => keywords.add(word));
+    }
+    if (feature.body) {
+      feature.body.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((word) => word.length > 3).forEach((word) => keywords.add(word));
+    }
+  });
+  const screenshots = landing.screenshots?.images || [];
+  screenshots.forEach((screenshot) => {
+    if (screenshot.title) {
+      screenshot.title.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((word) => word.length > 3).forEach((word) => keywords.add(word));
+    }
+    if (screenshot.description) {
+      screenshot.description.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((word) => word.length > 3).forEach((word) => keywords.add(word));
+    }
+  });
+  return Array.from(keywords);
+}
+function generateKeywordResearchQueries(args) {
+  const { currentKeywords, category, title, features = [], screenshots = [] } = args;
+  const queries = [];
+  if (category) {
+    const categoryName = category.toLowerCase().replace(/_/g, " ");
+    queries.push(`ASO keywords ${categoryName} app store optimization`);
+    queries.push(`best keywords for ${categoryName} apps`);
+    queries.push(`top ${categoryName} apps keywords`);
+  }
+  if (title) {
+    const titleWords = title.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+    titleWords.forEach((word) => {
+      queries.push(`${word} app keywords ASO`);
+    });
+  }
+  const featureTerms = /* @__PURE__ */ new Set();
+  features.forEach((feature) => {
+    if (feature.title) {
+      const words = feature.title.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 4);
+      words.forEach((word) => featureTerms.add(word));
+    }
+  });
+  Array.from(featureTerms).slice(0, 3).forEach((term) => {
+    queries.push(`${term} app store keywords`);
+  });
+  const screenshotTerms = /* @__PURE__ */ new Set();
+  screenshots.forEach((screenshot) => {
+    if (screenshot.title) {
+      const words = screenshot.title.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 4);
+      words.forEach((word) => screenshotTerms.add(word));
+    }
+  });
+  Array.from(screenshotTerms).slice(0, 3).forEach((term) => {
+    queries.push(`${term} app keywords`);
+  });
+  currentKeywords.slice(0, 5).forEach((keyword) => {
+    if (keyword.length > 3) {
+      queries.push(`${keyword} app store keywords`);
+    }
+  });
+  return queries;
+}
+
+// src/tools/aso/utils/improve/format-locale-section.util.ts
+function generateKeywordSuggestions(args) {
+  const { currentKeywords, category, title, description, locale, features = [], screenshots = [] } = args;
+  const analysis = analyzeKeywords(description);
+  const topKeywords = Object.entries(analysis.keywordDensity).sort(([, a], [, b]) => b - a).slice(0, 10).map(([word]) => word);
+  const researchQueries = generateKeywordResearchQueries({
+    currentKeywords,
+    category,
+    title,
+    locale,
+    features,
+    screenshots
+  });
+  let suggestions = `## Keyword Analysis & Research (${locale})
+
+`;
+  suggestions += `### Current Keywords:
+`;
+  suggestions += `- ${currentKeywords.join(", ") || "(none)"}
+
+`;
+  suggestions += `### Top Keywords Found in Content (by frequency):
+`;
+  topKeywords.slice(0, 10).forEach((keyword, idx) => {
+    const density = analysis.keywordDensity[keyword]?.toFixed(2) || "0";
+    suggestions += `${idx + 1}. "${keyword}" (density: ${density}%)
+`;
+  });
+  suggestions += `
+`;
+  suggestions += `### Keyword Research Queries (MULTIPLE SEARCH STRATEGIES REQUIRED):
+`;
+  suggestions += `**IMPORTANT**: Use ALL 5 search strategies below. Don't rely on just one approach.
+
+`;
+  suggestions += `#### Strategy 1: Direct Store Search
+`;
+  suggestions += `- Search App Store/Play Store: "${category ? category.toLowerCase().replace(/_/g, " ") : "category"} apps"
+`;
+  suggestions += `- Visit top 5-10 apps, extract keywords from their names, descriptions, screenshots
+
+`;
+  suggestions += `#### Strategy 2: ASO Guides & Tools
+`;
+  researchQueries.slice(0, 4).forEach((query, idx) => {
+    suggestions += `${idx + 1}. "${query}"
+`;
+  });
+  suggestions += `
+`;
+  suggestions += `#### Strategy 3: User Intent Searches
+`;
+  if (title) {
+    const titleWords = title.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+    titleWords.slice(0, 3).forEach((word, idx) => {
+      suggestions += `${idx + 1}. "${word} app"
+`;
+    });
+  }
+  suggestions += `- Search: "[primary feature] app", "[problem solved] app"
+
+`;
+  suggestions += `#### Strategy 4: Competitor Analysis
+`;
+  suggestions += `- Search: "top ${category ? category.toLowerCase().replace(/_/g, " ") : "category"} apps"
+`;
+  suggestions += `- "best ${category ? category.toLowerCase().replace(/_/g, " ") : "category"} apps 2024"
+
+`;
+  suggestions += `#### Strategy 5: Long-tail Keywords
+`;
+  currentKeywords.slice(0, 3).forEach((keyword, idx) => {
+    if (keyword.length > 3) {
+      suggestions += `${idx + 1}. "${keyword} app store keywords"
+`;
+    }
+  });
+  suggestions += `
+`;
+  suggestions += `**What to Extract**:
+`;
+  suggestions += `- Exact keyword phrases (2-4 words) from top apps
+`;
+  suggestions += `- Feature terms, benefit terms, category jargon
+`;
+  suggestions += `- Action verbs and technical terms
+`;
+  suggestions += `- Minimum 15-20 keywords, prioritize those used by 3+ top apps
+
+`;
+  suggestions += `### Keyword Optimization Guidelines:
+`;
+  suggestions += `1. **Keywords Array (CRITICAL)**: Update aso.keywords array with researched keywords. This directly impacts App Store search visibility
+`;
+  suggestions += `2. **Keyword Density**: Maintain 2.5-3% density for primary keywords, distributed naturally
+`;
+  suggestions += `3. **Title/Subtitle**: Include 1-2 core keywords (30 char limit)
+`;
+  suggestions += `4. **Short Description**: Include searchable keywords (80 char limit)
+`;
+  suggestions += `5. **Full Description**: Place primary keywords in first 2-3 lines, distribute naturally throughout
+`;
+  suggestions += `6. **template.intro**: Use up to 300 chars to naturally incorporate more keywords and provide richer context
+`;
+  suggestions += `7. **App Store Keywords**: 100 char limit, comma-separated, avoid duplicates from name/subtitle
+
+`;
+  if (category) {
+    suggestions += `### Category-Based Keyword Strategy:
+`;
+    suggestions += `Category: ${category}
+`;
+    suggestions += `- Research top-ranking apps in "${category}" category
+`;
+    suggestions += `- Identify common keywords used by successful competitors
+`;
+    suggestions += `- Focus on user search intent and specific terms users actually search for
+`;
+    suggestions += `- Avoid brand names and competitor names
+
+`;
+  }
+  return suggestions;
+}
+function formatLocaleSection(args) {
+  const {
+    slug,
+    locale,
+    localeData,
+    fullDescription,
+    primaryLocale,
+    category
+  } = args;
+  const aso = localeData.aso || {};
+  const template = aso.template;
+  const landing = localeData.landing || {};
+  const hero = landing.hero || {};
+  const screenshots = landing.screenshots?.images || [];
+  const features = landing.features?.items || [];
+  const lengthOf = (value) => value ? value.length : 0;
+  const keywordsLength = Array.isArray(aso.keywords) ? aso.keywords.join(", ").length : lengthOf(typeof aso.keywords === "string" ? aso.keywords : void 0);
+  const header = `--- ${locale}${locale === primaryLocale ? " (primary)" : ""} ---`;
+  const stats = [
+    `Path: public/products/${slug}/locales/${locale}.json`,
+    `- aso.title: ${lengthOf(aso.title)} chars`,
+    `- aso.subtitle: ${lengthOf(aso.subtitle)} chars`,
+    `- aso.shortDescription: ${lengthOf(aso.shortDescription)} chars`,
+    `- aso.keywords: ${keywordsLength} chars total`,
+    `- template.intro: ${lengthOf(template?.intro)} chars (limit: 300)`,
+    `- template.outro: ${lengthOf(template?.outro)} chars (limit: 200)`,
+    `- landing.hero.title: ${lengthOf(hero.title)} chars`,
+    `- landing.hero.description: ${lengthOf(hero.description)} chars`,
+    `- features: ${features.length} items`,
+    `- screenshots: ${screenshots.length} captions`,
+    `- fullDescription (derived): ${fullDescription?.length ?? 0} chars`
+  ].join("\n");
+  const currentKeywords = extractKeywordsFromContent(localeData);
+  const landingText = [
+    hero.title,
+    hero.description,
+    ...screenshots.map((img) => `${img.title} ${img.description || ""}`),
+    ...features.map((item) => `${item.title} ${item.body || ""}`),
+    landing.reviews?.title,
+    landing.reviews?.description,
+    landing.cta?.headline,
+    landing.cta?.description
+  ].filter(Boolean).join(" ");
+  const fullText = [
+    aso.title,
+    aso.subtitle,
+    aso.shortDescription,
+    template?.intro,
+    template?.outro,
+    fullDescription,
+    landingText
+  ].filter(Boolean).join(" ");
+  const keywordAnalysis = generateKeywordSuggestions({
+    currentKeywords,
+    category,
+    title: aso.title,
+    description: fullText,
+    locale,
+    features,
+    screenshots
+  });
+  const json = JSON.stringify(localeData, null, 2);
+  return `${header}
+${stats}
+
+${keywordAnalysis}
+\`\`\`json
+${json}
+\`\`\`
+`;
+}
+
+// src/tools/aso/utils/improve/generate-aso-prompt.util.ts
+var FIELD_LIMITS_DOC_PATH2 = "docs/aso/ASO_FIELD_LIMITS.md";
+function generatePrimaryOptimizationPrompt(args) {
+  const {
+    slug,
+    category,
+    primaryLocale,
+    localeSections,
+    keywordResearchByLocale,
+    keywordResearchDirByLocale
+  } = args;
+  let prompt = `# ASO Optimization - Stage 1: Primary Locale
+
+`;
+  prompt += `Product: ${slug} | Category: ${category || "N/A"} | Primary: ${primaryLocale}
+
+`;
+  prompt += `## Task
+
+`;
+  prompt += `Optimize the PRIMARY locale (${primaryLocale}) using **saved keyword research** + full ASO field optimization.
+
+`;
+  prompt += `## Step 1: Use Saved Keyword Research (${primaryLocale})
+
+`;
+  const researchSections = keywordResearchByLocale[primaryLocale] || [];
+  const researchDir = keywordResearchDirByLocale[primaryLocale];
+  if (researchSections.length > 0) {
+    prompt += `**CRITICAL: Use ONLY the saved keyword research below. Do NOT invent or research new keywords.**
+
+`;
+    prompt += `The research data includes:
+`;
+    prompt += `- **Tier 1 (Core):** Use these in title and subtitle - highest traffic, best opportunity
+`;
+    prompt += `- **Tier 2 (Feature):** Use these in keywords field and descriptions
+`;
+    prompt += `- **Tier 3 (Longtail):** Use these in intro, outro, and feature descriptions
+`;
+    prompt += `- **Keyword Details:** Each keyword has traffic/difficulty scores and rationale - use this to prioritize
+`;
+    prompt += `- **Strategy:** Overall optimization strategy based on competitor analysis
+`;
+    prompt += `- **Keyword Gaps:** Opportunities where competitors are weak
+`;
+    prompt += `- **User Language Patterns:** Phrases real users use in reviews - incorporate naturally
+
+`;
+    prompt += `Saved research:
+${researchSections.join("\n")}
+
+`;
+  } else {
+    prompt += `No saved keyword research found at ${researchDir}.
+`;
+    prompt += `**Stop and request action**: Run the 'keyword-research' tool with slug='${slug}', locale='${primaryLocale}', and the appropriate platform/country, then rerun improve-public stage 1.
+
+`;
+  }
+  prompt += `**Priority:** When both iOS and Android research exist, keep iOS keywords first and only add Android keywords if there is room after meeting character limits.
+
+`;
+  prompt += `## Step 2: Optimize All Fields (${primaryLocale})
+
+`;
+  prompt += `**Apply keywords strategically based on tier priority:**
+
+`;
+  prompt += `### Tier 1 Keywords (Core) \u2192 Title & Subtitle
+`;
+  prompt += `- \`aso.title\` (\u226430): **"App Name: [Tier1 Keyword]"** format
+`;
+  prompt += `  - App name in English, keyword in target language, uppercase after colon
+`;
+  prompt += `  - **Do NOT translate/rename the app name**
+`;
+  prompt += `- \`aso.subtitle\` (\u226430): Use remaining Tier 1 keywords
+`;
+  prompt += `- \`aso.shortDescription\` (\u226480): Tier 1 + Tier 2 keywords (no emojis/CAPS)
+
+`;
+  prompt += `### Tier 2 Keywords (Feature) \u2192 Keywords Field & Descriptions
+`;
+  prompt += `- \`aso.keywords\` (\u2264100): ALL tiers, comma-separated (Tier 1 first, then Tier 2, then Tier 3)
+`;
+  prompt += `- \`landing.hero.title\`: Tier 1 + Tier 2 keywords
+`;
+  prompt += `- \`landing.hero.description\`: Tier 2 keywords naturally integrated
+`;
+  prompt += `- \`landing.screenshots.images[].title\`: Tier 2 keywords
+`;
+  prompt += `- \`landing.screenshots.images[].description\`: Tier 2 + Tier 3 keywords
+
+`;
+  prompt += `### Tier 3 Keywords (Longtail) \u2192 Content Sections
+`;
+  prompt += `- \`aso.template.intro\` (\u2264300): Tier 2 + Tier 3 keywords, keyword-rich, use full length
+`;
+  prompt += `- \`aso.template.outro\` (\u2264200): Tier 3 keywords, natural integration
+`;
+  prompt += `- \`landing.features.items[].title\`: Tier 2 keywords
+`;
+  prompt += `- \`landing.features.items[].body\`: Tier 3 keywords with user language patterns
+`;
+  prompt += `- \`landing.reviews.title/description\`: Keywords if applicable
+`;
+  prompt += `- \`landing.cta.headline/description\`: Keywords if applicable
+
+`;
+  prompt += `### User Language Integration
+`;
+  prompt += `- Use **User Language Patterns** from research in intro/outro/features
+`;
+  prompt += `- These are actual phrases users search for - incorporate naturally
+
+`;
+  prompt += `**Guidelines**: 2.5-3% keyword density, natural flow, cultural appropriateness
+`;
+  prompt += `**CRITICAL**: You MUST include the complete \`landing\` object in your optimized JSON output.
+
+`;
+  prompt += `## Step 3: Validate (after applying all keywords)
+
+`;
+  prompt += `Check all limits using ${FIELD_LIMITS_DOC_PATH2}: title \u226430, subtitle \u226430, shortDescription \u226480, keywords \u2264100, intro \u2264300, outro \u2264200
+`;
+  prompt += `- Remove keyword duplicates (unique list; avoid repeating title/subtitle terms verbatim)
+`;
+  prompt += `- Ensure App Store/Play Store rules from ${FIELD_LIMITS_DOC_PATH2} are satisfied (no disallowed characters/formatting)
+
+`;
+  prompt += `## Current Data
+
+`;
+  prompt += `${localeSections.find((s) => s.includes(`[${primaryLocale}]`)) || localeSections[0]}
+
+`;
+  prompt += `## Output Format
+
+`;
+  prompt += `**1. Keyword Research (from saved data)**
+`;
+  prompt += `   - Cite file(s) used and list the selected top 10 keywords (no new research)
+`;
+  prompt += `   - Rationale: why these 10 were chosen from saved research
+
+`;
+  prompt += `**2. Optimized JSON** (complete ${primaryLocale} locale structure)
+`;
+  prompt += `   - MUST include complete \`aso\` object with all fields
+`;
+  prompt += `   - MUST include complete \`landing\` object with:
+`;
+  prompt += `     * \`landing.hero\` (title, description, titleHighlight)
+`;
+  prompt += `     * \`landing.screenshots.images[]\` (all items with title and description)
+`;
+  prompt += `     * \`landing.features.items[]\` (all items with title and body)
+`;
+  prompt += `     * \`landing.reviews\` (title, description, icons, rating, testimonials)
+`;
+  prompt += `     * \`landing.cta\` (headline, icons, rating, description)
+
+`;
+  prompt += `**3. Validation**
+`;
+  prompt += `   - title: X/30 \u2713/\u2717
+`;
+  prompt += `   - subtitle: X/30 \u2713/\u2717
+`;
+  prompt += `   - shortDescription: X/80 \u2713/\u2717
+`;
+  prompt += `   - keywords: X/100 \u2713/\u2717 (deduped \u2713/\u2717)
+`;
+  prompt += `   - intro: X/300 \u2713/\u2717
+`;
+  prompt += `   - outro: X/200 \u2713/\u2717
+`;
+  prompt += `   - Store rules (${FIELD_LIMITS_DOC_PATH2}): \u2713/\u2717
+`;
+  prompt += `   - Density: X% (2.5-3%) \u2713/\u2717
+
+`;
+  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;
+}
+function generateKeywordLocalizationPrompt(args) {
+  const {
+    slug,
+    primaryLocale,
+    targetLocales,
+    localeSections,
+    optimizedPrimary,
+    keywordResearchByLocale,
+    keywordResearchDirByLocale,
+    batchLocales,
+    batchIndex,
+    totalBatches,
+    batchLocaleSections
+  } = args;
+  const nonPrimaryLocales = batchLocales || targetLocales.filter((l) => l !== primaryLocale);
+  const sectionsToUse = batchLocaleSections || localeSections;
+  let prompt = `# ASO Optimization - Stage 2: Keyword Localization`;
+  if (batchIndex !== void 0 && totalBatches !== void 0) {
+    prompt += ` (Batch ${batchIndex + 1}/${totalBatches})`;
+  }
+  prompt += `
+
+`;
+  prompt += `Product: ${slug} | Primary: ${primaryLocale} | Batch Locales: ${nonPrimaryLocales.join(
+    ", "
+  )}
+
+`;
+  if (batchIndex !== void 0 && totalBatches !== void 0) {
+    prompt += `**\u26A0\uFE0F BATCH PROCESSING MODE**
+
+`;
+    prompt += `This is batch ${batchIndex + 1} of ${totalBatches}.
+`;
+    prompt += `Process ONLY the locales in this batch: ${nonPrimaryLocales.join(
+      ", "
+    )}
+`;
+    prompt += `After completing this batch, save the files and proceed to the next batch.
+
+`;
+  }
+  prompt += `## Task
+
+`;
+  prompt += `**CRITICAL: Only process locales that already exist in public/products/${slug}/locales/.**
+`;
+  prompt += `**Do NOT create new locale files - only improve existing ones.**
+
+`;
+  prompt += `For EACH target locale in this batch:
+`;
+  prompt += `1. Use SAVED keyword research (see per-locale data below). Do NOT invent keywords.
+`;
+  prompt += `2. **Replace ONLY keywords with optimized keywords** - keep ALL existing content, structure, tone, and context unchanged. Only swap keywords for better ASO keywords.
+`;
+  prompt += `3. After all keywords are applied, validate character limits + store rules (${FIELD_LIMITS_DOC_PATH2}) + keyword duplication
+`;
+  prompt += `4. **SAVE the updated JSON to file** using the save-locale-file tool (only if file exists)
+
+`;
+  prompt += `## Optimized Primary (Reference)
+
+`;
+  prompt += `Use this as the base structure/messaging:
+\`\`\`json
+${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 && localesNeedingFallback.length > 0) {
+    prompt += `---
+`;
+    prompt += `**\u{1F4DA} ENGLISH FALLBACK (${primaryLocale})** - Only for locales without their own research: ${localesNeedingFallback.join(
+      ", "
+    )}
+`;
+    prompt += `${primaryResearchSections.join("\n")}
+
+`;
+    prompt += `---
+
+`;
+  }
+  nonPrimaryLocales.forEach((loc) => {
+    const researchSections = keywordResearchByLocale[loc] || [];
+    const researchDir = keywordResearchDirByLocale[loc];
+    const fallbackInfo = keywordResearchFallbackByLocale?.[loc];
+    if (researchSections.length > 0 && !fallbackInfo?.isFallback) {
+      prompt += `### Locale ${loc}: \u2705 Using locale-specific keyword research
+`;
+      prompt += researchSections.join("\n");
+      prompt += `
+**Use these ${loc} keywords directly** - they are already in the target language.
+
+`;
+    } else if (researchSections.length > 0 && fallbackInfo?.isFallback) {
+      prompt += `### Locale ${loc}: \u{1F504} No ${loc} research found - Using ${fallbackInfo.fallbackLocale} as fallback
+`;
+      prompt += researchSections.join("\n");
+      prompt += `
+**MUST TRANSLATE:** The keywords above are in ${fallbackInfo.fallbackLocale}. You MUST:
+`;
+      prompt += `1. **TRANSLATE each keyword into ${loc}** - use natural, native expressions
+`;
+      prompt += `2. Ensure translated keywords are what ${loc} users would actually search for
+`;
+      prompt += `3. **DO NOT use ${fallbackInfo.fallbackLocale} keywords directly** - all keywords must be in ${loc} language
+
+`;
+    } else if (hasPrimaryResearch) {
+      prompt += `### Locale ${loc}: \u26A0\uFE0F No research found - TRANSLATE from English fallback above
+`;
+      prompt += `No keyword research found at ${researchDir}.
+`;
+      prompt += `**Use the ENGLISH FALLBACK section above** and TRANSLATE all keywords to ${loc}.
+
+`;
+    } else {
+      prompt += `### Locale ${loc}: \u274C No research available
+`;
+      prompt += `No keyword research found. Extract keywords from \`aso.keywords\` in optimizedPrimary and **TRANSLATE them to ${loc}**.
+
+`;
+    }
+  });
+  prompt += `## Keyword Replacement Strategy
+
+`;
+  prompt += `**CRITICAL: Keep ALL existing content unchanged. Only replace keywords with optimized keywords.**
+
+`;
+  prompt += `For EACH locale:
+`;
+  prompt += `- Priority: Keep iOS-sourced keywords first; add Android keywords only if there is remaining space after iOS keywords fit within field limits.
+`;
+  prompt += `1. Take the EXISTING translated content (below) - **DO NOT change the content itself**
+`;
+  prompt += `2. Replace \`aso.keywords\` array with optimized keywords (keep same count/structure)
+`;
+  prompt += `3. **TITLE FORMAT**: \`aso.title\` must follow **"App Name: Primary Keyword"** format:
+`;
+  prompt += `   - App name: **ALWAYS in English** (e.g., "Aurora EOS", "Timeline", "Recaply)
+`;
+  prompt += `   - Primary keyword: **In target language** (e.g., "\uC624\uB85C\uB77C \uC608\uBCF4" for Korean, "\u30AA\u30FC\u30ED\u30E9\u4E88\u5831" for Japanese)
+`;
+  prompt += `   - Example: "Aurora EOS: \uC624\uB85C\uB77C \uC608\uBCF4" (Korean), "Aurora EOS: \u30AA\u30FC\u30ED\u30E9\u4E88\u5831" (Japanese)
+`;
+  prompt += `   - The keyword after the colon must start with an uppercase letter
+`;
+  prompt += `   - **Do NOT translate/rename the app name**; keep the original English app name across all locales.
+`;
+  prompt += `   - **Only replace the keyword part** - keep the app name and format structure unchanged
+`;
+  prompt += `4. Deduplicate keywords: final \`aso.keywords\` must be unique and should not repeat title/subtitle terms verbatim
+`;
+  prompt += `5. **Replace keywords in existing sentences** - swap ONLY the keywords, keep everything else:
+`;
+  prompt += `   - **Keep original sentence structure exactly as is**
+`;
+  prompt += `   - **Keep original tone and messaging unchanged**
+`;
+  prompt += `   - **Keep original context and flow unchanged**
+`;
+  prompt += `   - **Only swap individual keywords** for better ASO keywords
+`;
+  prompt += `   - Maintain character limits
+
+`;
+  prompt += `6. **CRITICAL**: Update keywords in ALL \`landing\` sections (replace keywords only, keep content structure):
+`;
+  prompt += `   - \`landing.hero.title\` and \`landing.hero.description\`: Replace keywords only, keep existing text structure
+`;
+  prompt += `   - \`landing.screenshots.images[].title\`: Replace keywords in existing titles, keep structure
+`;
+  prompt += `   - \`landing.screenshots.images[].description\`: Replace keywords in existing descriptions, keep structure
+`;
+  prompt += `   - \`landing.features.items[].title\`: Replace keywords in existing titles, keep structure
+`;
+  prompt += `   - \`landing.features.items[].body\`: Replace keywords in existing descriptions, keep structure
+`;
+  prompt += `   - \`landing.reviews.title\` and \`landing.reviews.description\`: Replace keywords if applicable, keep structure
+`;
+  prompt += `   - \`landing.cta.headline\` and \`landing.cta.description\`: Replace keywords if applicable, keep structure
+`;
+  prompt += `   - **Maintain ALL original context, meaning, and structure**
+`;
+  prompt += `   - Use optimized keywords that users actually search for
+`;
+  prompt += `   - **DO NOT rewrite or restructure content** - only replace keywords
+
+`;
+  prompt += `**Example** (keyword replacement only, content unchanged):
+`;
+  prompt += `- Original: "Track aurora with real-time forecasts"
+`;
+  prompt += `- Optimized keywords: \uC624\uB85C\uB77C, \uC608\uBCF4, \uC2E4\uC2DC\uAC04
+`;
+  prompt += `- Result: "Track \uC624\uB85C\uB77C with \uC2E4\uC2DC\uAC04 \uC608\uBCF4" (keywords replaced, structure kept)
+`;
+  prompt += `  OR: "\uC2E4\uC2DC\uAC04 \uC608\uBCF4\uB85C \uC624\uB85C\uB77C \uCD94\uC801" (if natural keyword placement requires minor word order, but keep meaning identical)
+
+`;
+  prompt += `## Current Translated Locales (This Batch)
+
+`;
+  nonPrimaryLocales.forEach((loc) => {
+    const section = sectionsToUse.find((s) => s.includes(`[${loc}]`));
+    if (section) {
+      prompt += `${section}
+
+`;
+    }
+  });
+  prompt += `## Workflow
+
+`;
+  prompt += `Process EACH locale in this batch sequentially:
+`;
+  prompt += `1. Use saved keyword research (in target language) OR **TRANSLATE English keywords from primary locale** if missing (see fallback strategy above - MUST translate, not use English directly)
+`;
+  prompt += `2. **Replace keywords ONLY** in ALL fields (keep existing content structure unchanged):
+`;
+  prompt += `   - \`aso.keywords\` array
+`;
+  prompt += `   - \`aso.title\`, \`aso.subtitle\`, \`aso.shortDescription\`
+`;
+  prompt += `   - \`aso.template.intro\`, \`aso.template.outro\`
+`;
+  prompt += `   - \`landing.hero.title\` and \`landing.hero.description\`
+`;
+  prompt += `   - \`landing.screenshots.images[].title\` and \`description\` (ALL items)
+`;
+  prompt += `   - \`landing.features.items[].title\` and \`body\` (ALL items)
+`;
+  prompt += `   - \`landing.reviews.title\` and \`landing.reviews.description\`
+`;
+  prompt += `   - **For each field: Replace keywords only, keep existing content structure and meaning unchanged**
+`;
+  prompt += `3. **CRITICAL**: Ensure ALL landing fields are translated (not English)
+`;
+  prompt += `4. After swapping keywords, validate limits + store rules (${FIELD_LIMITS_DOC_PATH2}) + keyword duplication (unique list; avoid repeating title/subtitle terms verbatim)
+`;
+  prompt += `5. **SAVE the updated JSON to file** using save-locale-file tool
+`;
+  prompt += `6. Move to next locale in batch
+
+`;
+  if (batchIndex !== void 0 && totalBatches !== void 0) {
+    prompt += `## After Completing This Batch
+
+`;
+    prompt += `1. Verify all locales in this batch have been saved to files
+`;
+    if (batchIndex + 1 < totalBatches) {
+      prompt += `2. Proceed to next batch (batch ${batchIndex + 2}/${totalBatches})
+`;
+      prompt += `3. Use the same optimizedPrimary JSON as reference
+
+`;
+    } else {
+      prompt += `2. All batches completed! \u2705
+`;
+      prompt += `3. **Run validate-aso** to verify all locales:
+`;
+      prompt += `   \`\`\`
+   validate-aso(slug="${slug}")
+   \`\`\`
+
+`;
+    }
+  }
+  prompt += `## Output Format (Per Locale)
+
+`;
+  prompt += `For EACH locale, provide:
+
+`;
+  prompt += `### Locale [locale-code]:
+
+`;
+  prompt += `**1. Keyword Source**
+`;
+  prompt += `   - If saved research exists: Cite file(s) used; list selected top 10 keywords (in target language)
+`;
+  prompt += `   - If using fallback: List **TRANSLATED** keywords from primary locale (English \u2192 target language) with translation rationale
+`;
+  prompt += `   - Show final 10 keywords **IN TARGET LANGUAGE** with tier assignments - DO NOT show English keywords
+
+`;
+  prompt += `**2. Updated JSON** (complete locale structure with keyword replacements only)
+`;
+  prompt += `   - **CRITICAL**: Keep ALL existing content structure and meaning unchanged - only replace keywords
+`;
+  prompt += `   - MUST include complete \`aso\` object (keywords replaced, content structure kept)
+`;
+  prompt += `   - MUST include complete \`landing\` object with ALL sections (keywords replaced, content structure kept):
+`;
+  prompt += `     * hero (title, description, titleHighlight) - replace keywords only
+`;
+  prompt += `     * screenshots.images[] (all items with keywords replaced in existing titles/descriptions)
+`;
+  prompt += `     * features.items[] (all items with keywords replaced in existing titles/bodies)
+`;
+  prompt += `     * reviews (title, description, icons, rating, testimonials) - replace keywords if applicable
+`;
+  prompt += `     * cta (headline, icons, rating, description) - replace keywords if applicable
+`;
+  prompt += `   - **NO English text in landing sections** - everything must be translated
+`;
+  prompt += `   - **DO NOT rewrite or restructure content** - only swap keywords for optimized keywords
+
+`;
+  prompt += `**3. Validation**
+`;
+  prompt += `   - title: X/30 \u2713/\u2717
+`;
+  prompt += `   - subtitle: X/30 \u2713/\u2717
+`;
+  prompt += `   - shortDescription: X/80 \u2713/\u2717
+`;
+  prompt += `   - keywords: X/100 \u2713/\u2717 (deduped \u2713/\u2717; not repeating title/subtitle)
+`;
+  prompt += `   - intro: X/300 \u2713/\u2717
+`;
+  prompt += `   - outro: X/200 \u2713/\u2717
+`;
+  prompt += `   - Store rules (${FIELD_LIMITS_DOC_PATH2}): \u2713/\u2717
+
+`;
+  prompt += `**4. File Save Confirmation**
+`;
+  prompt += `   - Confirm file saved: public/products/${slug}/locales/[locale-code].json
+`;
+  prompt += `   - **Only save if the file already exists** - do not create new files
+
+`;
+  prompt += `---
+
+`;
+  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;
+}
+
+// src/tools/aso/utils/improve/load-keyword-research.util.ts
+import fs6 from "fs";
+import path6 from "path";
+function extractRecommended(data) {
+  const summary = data?.summary || data?.data?.summary;
+  const recommended = summary?.recommendedKeywords;
+  if (Array.isArray(recommended)) {
+    return recommended.map((item) => {
+      if (typeof item === "object" && item?.keyword) {
+        return {
+          keyword: String(item.keyword),
+          tier: String(item.tier || ""),
+          difficulty: Number(item.difficulty) || 0,
+          traffic: Number(item.traffic) || 0,
+          rationale: String(item.rationale || "")
+        };
+      }
+      if (typeof item === "string") {
+        return { keyword: item, tier: "", difficulty: 0, traffic: 0, rationale: "" };
+      }
+      return null;
+    }).filter((item) => item !== null);
+  }
+  return [];
+}
+function extractKeywordsByTier(data) {
+  const summary = data?.summary || data?.data?.summary;
+  const byTier = summary?.keywordsByTier || {};
+  const extractKeywords = (tier) => Array.isArray(tier) ? tier.map((k) => typeof k === "object" ? k.keyword : String(k)).filter(Boolean) : [];
+  return {
+    tier1_core: extractKeywords(byTier.tier1_core),
+    tier2_feature: extractKeywords(byTier.tier2_feature),
+    tier3_longtail: extractKeywords(byTier.tier3_longtail)
+  };
+}
+function extractRationale(data) {
+  const summary = data?.summary || data?.data?.summary;
+  return summary?.rationale || "";
+}
+function extractCompetitorInsights(data) {
+  const summary = data?.summary || data?.data?.summary;
+  const insights = summary?.competitorInsights || {};
+  return {
+    keywordGaps: Array.isArray(insights.keywordGaps) ? insights.keywordGaps : [],
+    userLanguagePatterns: Array.isArray(insights.userLanguagePatterns) ? insights.userLanguagePatterns : []
+  };
+}
+function extractMeta(data) {
+  const meta = data?.meta || data?.data?.meta || {};
+  return {
+    platform: meta.platform,
+    country: meta.country,
+    seedKeywords: Array.isArray(meta.seedKeywords) ? meta.seedKeywords.map(String) : void 0,
+    competitorApps: Array.isArray(meta.competitorApps) ? meta.competitorApps : void 0
+  };
+}
+function formatEntry(entry) {
+  const { filePath, data } = entry;
+  const recommended = extractRecommended(data);
+  const meta = extractMeta(data);
+  const byTier = extractKeywordsByTier(data);
+  const rationale = extractRationale(data);
+  const insights = extractCompetitorInsights(data);
+  if (data?.parseError) {
+    return `File: ${filePath}
+Parse error: ${data.parseError}
+----`;
+  }
+  const lines = [];
+  lines.push(`### File: ${filePath}`);
+  if (meta.platform || meta.country) {
+    lines.push(
+      `Platform: ${meta.platform || "unknown"} | Country: ${meta.country || "unknown"}`
+    );
+  }
+  if (byTier.tier1_core.length > 0) {
+    lines.push(`
+**Tier 1 (Core - use in title/subtitle):** ${byTier.tier1_core.join(", ")}`);
+  }
+  if (byTier.tier2_feature.length > 0) {
+    lines.push(`**Tier 2 (Feature - use in keywords field/descriptions):** ${byTier.tier2_feature.join(", ")}`);
+  }
+  if (byTier.tier3_longtail.length > 0) {
+    lines.push(`**Tier 3 (Longtail - use in intro/outro/features):** ${byTier.tier3_longtail.join(", ")}`);
+  }
+  if (recommended.length > 0) {
+    lines.push(`
+**Keyword Details (${recommended.length} keywords):**`);
+    recommended.forEach((kw, idx) => {
+      const tierLabel = kw.tier ? ` [${kw.tier}]` : "";
+      const scores = kw.traffic > 0 || kw.difficulty > 0 ? ` (traffic: ${kw.traffic.toFixed(2)}, difficulty: ${kw.difficulty.toFixed(2)})` : "";
+      lines.push(`${idx + 1}. **${kw.keyword}**${tierLabel}${scores}`);
+      if (kw.rationale) {
+        lines.push(`   \u2192 ${kw.rationale}`);
+      }
+    });
+  }
+  if (rationale) {
+    lines.push(`
+**Strategy:** ${rationale}`);
+  }
+  if (insights.keywordGaps.length > 0) {
+    lines.push(`
+**Keyword Gaps (opportunities):**`);
+    insights.keywordGaps.forEach((gap) => lines.push(`- ${gap}`));
+  }
+  if (insights.userLanguagePatterns.length > 0) {
+    lines.push(`
+**User Language Patterns (from reviews):**`);
+    insights.userLanguagePatterns.forEach((pattern) => lines.push(`- ${pattern}`));
+  }
+  lines.push("\n----");
+  return lines.join("\n");
+}
+function getPlatformPriority(platform) {
+  const normalized = (platform || "").toLowerCase();
+  if (normalized === "ios") return 0;
+  if (normalized === "android") return 1;
+  return 2;
+}
+function mergeKeywordData(entries) {
+  const merged = {
+    tier1_core: [],
+    tier2_feature: [],
+    tier3_longtail: [],
+    allKeywords: [],
+    rationale: "",
+    keywordGaps: [],
+    userLanguagePatterns: [],
+    platforms: []
+  };
+  const seenKeywords = /* @__PURE__ */ new Set();
+  const seenGaps = /* @__PURE__ */ new Set();
+  const seenPatterns = /* @__PURE__ */ new Set();
+  const entriesByPriority = [...entries].sort((a, b) => {
+    const aPriority = getPlatformPriority(extractMeta(a.data).platform);
+    const bPriority = getPlatformPriority(extractMeta(b.data).platform);
+    return aPriority - bPriority;
+  });
+  for (const entry of entriesByPriority) {
+    if (entry.data?.parseError) continue;
+    const meta = extractMeta(entry.data);
+    if (meta.platform && !merged.platforms.includes(meta.platform)) {
+      merged.platforms.push(meta.platform);
+    }
+    const byTier = extractKeywordsByTier(entry.data);
+    byTier.tier1_core.forEach((kw) => {
+      if (!seenKeywords.has(kw.toLowerCase())) {
+        merged.tier1_core.push(kw);
+        seenKeywords.add(kw.toLowerCase());
+      }
+    });
+    byTier.tier2_feature.forEach((kw) => {
+      if (!seenKeywords.has(kw.toLowerCase())) {
+        merged.tier2_feature.push(kw);
+        seenKeywords.add(kw.toLowerCase());
+      }
+    });
+    byTier.tier3_longtail.forEach((kw) => {
+      if (!seenKeywords.has(kw.toLowerCase())) {
+        merged.tier3_longtail.push(kw);
+        seenKeywords.add(kw.toLowerCase());
+      }
+    });
+    const recommended = extractRecommended(entry.data);
+    for (const kw of recommended) {
+      if (!seenKeywords.has(kw.keyword.toLowerCase())) {
+        merged.allKeywords.push(kw);
+        seenKeywords.add(kw.keyword.toLowerCase());
+      }
+    }
+    const rationale = extractRationale(entry.data);
+    if (rationale && !merged.rationale) {
+      merged.rationale = rationale;
+    } else if (rationale && merged.rationale) {
+      merged.rationale += ` | ${meta.platform}: ${rationale}`;
+    }
+    const insights = extractCompetitorInsights(entry.data);
+    insights.keywordGaps.forEach((gap) => {
+      if (!seenGaps.has(gap)) {
+        merged.keywordGaps.push(gap);
+        seenGaps.add(gap);
+      }
+    });
+    insights.userLanguagePatterns.forEach((pattern) => {
+      if (!seenPatterns.has(pattern)) {
+        merged.userLanguagePatterns.push(pattern);
+        seenPatterns.add(pattern);
+      }
+    });
+  }
+  merged.allKeywords.sort((a, b) => b.traffic - a.traffic);
+  return merged;
+}
+function formatMergedData(merged, researchDir) {
+  const lines = [];
+  const hasIos = merged.platforms.some(
+    (platform) => platform && platform.toLowerCase() === "ios"
+  );
+  const platformLabel = merged.platforms.length > 0 ? merged.platforms.join(" + ") : "Unknown";
+  lines.push(
+    `### Combined Keyword Research (${platformLabel})${hasIos ? " \u2014 iOS prioritized" : ""}`
+  );
+  lines.push(`Source: ${researchDir}`);
+  lines.push(`Priority: iOS > Android > others (use Android only after iOS keywords fit character limits)`);
+  if (merged.tier1_core.length > 0) {
+    lines.push(`
+**Tier 1 (Core - use in title/subtitle):** ${merged.tier1_core.join(", ")}`);
+  }
+  if (merged.tier2_feature.length > 0) {
+    lines.push(`**Tier 2 (Feature - use in keywords field/descriptions):** ${merged.tier2_feature.join(", ")}`);
+  }
+  if (merged.tier3_longtail.length > 0) {
+    lines.push(`**Tier 3 (Longtail - use in intro/outro/features):** ${merged.tier3_longtail.join(", ")}`);
+  }
+  if (merged.allKeywords.length > 0) {
+    lines.push(`
+**Top Keywords by Traffic (${merged.allKeywords.length} total):**`);
+    merged.allKeywords.slice(0, 15).forEach((kw, idx) => {
+      const tierLabel = kw.tier ? ` [${kw.tier}]` : "";
+      const scores = kw.traffic > 0 || kw.difficulty > 0 ? ` (traffic: ${kw.traffic.toFixed(2)}, difficulty: ${kw.difficulty.toFixed(2)})` : "";
+      lines.push(`${idx + 1}. **${kw.keyword}**${tierLabel}${scores}`);
+      if (kw.rationale) {
+        lines.push(`   \u2192 ${kw.rationale}`);
+      }
+    });
+  }
+  if (merged.rationale) {
+    lines.push(`
+**Strategy:** ${merged.rationale}`);
+  }
+  if (merged.keywordGaps.length > 0) {
+    lines.push(`
+**Keyword Gaps (opportunities):**`);
+    merged.keywordGaps.slice(0, 5).forEach((gap) => lines.push(`- ${gap}`));
+  }
+  if (merged.userLanguagePatterns.length > 0) {
+    lines.push(`
+**User Language Patterns (from reviews):**`);
+    merged.userLanguagePatterns.slice(0, 5).forEach((pattern) => lines.push(`- ${pattern}`));
+  }
+  lines.push("\n----");
+  return lines.join("\n");
+}
+function loadKeywordResearchForLocaleInternal(slug, locale) {
+  const researchDir = path6.join(
+    getKeywordResearchDir(),
+    "products",
+    slug,
+    "locales",
+    locale
+  );
+  if (!fs6.existsSync(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);
+    try {
+      const raw = fs6.readFileSync(filePath, "utf-8");
+      const data = JSON.parse(raw);
+      entries.push({ filePath, data });
+    } catch (err) {
+      entries.push({
+        filePath,
+        data: {
+          parseError: err instanceof Error ? err.message : "Unknown parse error"
+        }
+      });
+    }
+  }
+  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 };
+  }
+  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/aso/improve.ts
+var toJsonSchema3 = zodToJsonSchema3;
+var improvePublicInputSchema = z3.object({
+  slug: z3.string().describe("Product slug"),
+  locale: z3.string().optional().describe("Locale to improve (default: all locales)"),
+  stage: z3.enum(["1", "2", "both"]).optional().describe(
+    "Stage to execute: 1 (primary only), 2 (keyword localization), both (default)"
+  ),
+  optimizedPrimary: z3.string().optional().describe("Optimized primary locale JSON (required for stage 2)"),
+  batchSize: z3.number().int().positive().optional().default(5).describe(
+    "Number of locales to process per batch (default: 5, for stage 2 only)"
+  ),
+  batchIndex: z3.number().int().nonnegative().optional().describe(
+    "Batch index to process (0-based, for stage 2 only). If not provided, processes all batches sequentially"
+  )
+});
+var jsonSchema3 = toJsonSchema3(improvePublicInputSchema, {
+  name: "ImprovePublicInput",
+  $refStrategy: "none"
+});
+var inputSchema3 = jsonSchema3.definitions?.ImprovePublicInput || jsonSchema3;
+var improvePublicTool = {
+  name: "improve-public",
+  description: `Returns ASO optimization instructions with keyword research data. **You MUST execute the returned instructions.**
+
+**IMPORTANT:** Use 'search-app' tool first to resolve the exact slug.
+
+## HOW THIS TOOL WORKS
+This tool returns a PROMPT containing:
+- Saved keyword research data (Tier 1/2/3 keywords with traffic/difficulty scores)
+- Current locale data
+- Optimization instructions
+
+**YOU MUST:**
+1. Read the returned prompt carefully
+2. EXECUTE the optimization instructions (create the optimized JSON)
+3. Save results using 'save-locale-file' tool
+
+**DO NOT** just report the instructions back to the user - you must perform the optimization yourself.
+
+## WORKFLOW
+**Stage 1:** improve-public(slug, stage="1") \u2192 Returns keyword data + instructions \u2192 You create optimized primary locale JSON \u2192 save-locale-file
+**Stage 2:** improve-public(slug, stage="2", optimizedPrimary=<JSON>) \u2192 Returns per-locale instructions \u2192 You optimize each locale \u2192 save-locale-file for each
+
+## STAGES
+- **Stage 1:** Primary locale optimization using saved keyword research (ios + android combined)
+- **Stage 2:** Localize to other languages - **each locale uses its OWN keyword research**
+
+## 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
+};
+async function handleImprovePublic(input) {
+  const {
+    slug,
+    locale,
+    stage = "both",
+    optimizedPrimary,
+    batchSize = 5,
+    batchIndex
+  } = input;
+  const { config, locales } = loadProductLocales(slug);
+  const primaryLocale = resolvePrimaryLocale(config, locales);
+  if (locale && !locales[locale]) {
+    throw new Error(
+      `Locale "${locale}" not found in public/products/${slug}/locales/. Only existing locale files are processed - new files are not created.`
+    );
+  }
+  const requestedLocales = locale ? [locale] : Object.keys(locales);
+  const existingRequestedLocales = requestedLocales.filter(
+    (loc) => locales[loc]
+  );
+  if (existingRequestedLocales.length === 0) {
+    throw new Error(
+      `No existing locales found to process. Only existing locale files in public/products/${slug}/locales/ are processed.`
+    );
+  }
+  const localeSet = /* @__PURE__ */ new Set([
+    ...existingRequestedLocales,
+    primaryLocale
+  ]);
+  const targetLocales = [...localeSet].filter((loc) => locales[loc]);
+  const asoData = loadAsoFromConfig(slug);
+  const category = config?.metadata?.category;
+  const localeSections = [];
+  for (const loc of localeSet) {
+    const localeData = locales[loc];
+    if (!localeData) {
+      continue;
+    }
+    const fullDescription = getFullDescriptionForLocale(asoData, loc);
+    localeSections.push(
+      formatLocaleSection({
+        slug,
+        locale: loc,
+        localeData,
+        fullDescription,
+        primaryLocale,
+        category
+      })
+    );
+  }
+  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,
+    category,
+    primaryLocale,
+    targetLocales,
+    localeSections,
+    keywordResearchByLocale,
+    keywordResearchDirByLocale,
+    keywordResearchFallbackByLocale
+  };
+  if (stage === "1" || stage === "both") {
+    const prompt = generatePrimaryOptimizationPrompt(baseArgs);
+    return {
+      content: [
+        {
+          type: "text",
+          text: prompt
+        }
+      ]
+    };
+  }
+  if (stage === "2") {
+    if (!optimizedPrimary) {
+      throw new Error(
+        "Stage 2 requires optimizedPrimary parameter. Run stage 1 first or use stage='both'."
+      );
+    }
+    const nonPrimaryLocales = targetLocales.filter((l) => l !== primaryLocale);
+    const totalBatches = Math.ceil(nonPrimaryLocales.length / batchSize);
+    let batchesToProcess;
+    if (batchIndex !== void 0) {
+      if (batchIndex < 0 || batchIndex >= totalBatches) {
+        throw new Error(
+          `Batch index ${batchIndex} is out of range. Total batches: ${totalBatches} (0-${totalBatches - 1})`
+        );
+      }
+      batchesToProcess = [batchIndex];
+    } else {
+      batchesToProcess = Array.from({ length: totalBatches }, (_, i) => i);
+    }
+    const batchPrompts = [];
+    for (const currentBatchIndex of batchesToProcess) {
+      const startIdx = currentBatchIndex * batchSize;
+      const endIdx = Math.min(startIdx + batchSize, nonPrimaryLocales.length);
+      const batchLocales = nonPrimaryLocales.slice(startIdx, endIdx);
+      const batchLocaleSections = localeSections.filter((section) => {
+        return batchLocales.some((loc) => section.includes(`[${loc}]`));
+      });
+      const promptArgs = {
+        slug: baseArgs.slug,
+        category: baseArgs.category,
+        primaryLocale: baseArgs.primaryLocale,
+        targetLocales: baseArgs.targetLocales,
+        localeSections: baseArgs.localeSections,
+        keywordResearchByLocale: baseArgs.keywordResearchByLocale,
+        keywordResearchDirByLocale: baseArgs.keywordResearchDirByLocale,
+        keywordResearchFallbackByLocale: baseArgs.keywordResearchFallbackByLocale,
+        optimizedPrimary,
+        batchLocales,
+        batchIndex: currentBatchIndex,
+        totalBatches,
+        batchLocaleSections
+      };
+      const prompt = generateKeywordLocalizationPrompt(promptArgs);
+      batchPrompts.push(prompt);
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: batchPrompts.join("\n\n---\n\n")
+        }
+      ]
+    };
+  }
+  throw new Error(`Invalid stage: ${stage}. Must be "1", "2", or "both".`);
+}
+
+// src/tools/aso/validate.ts
+import { z as z4 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema4 } from "zod-to-json-schema";
+var toJsonSchema4 = zodToJsonSchema4;
+var validateAsoInputSchema = z4.object({
+  slug: z4.string().describe("Product slug"),
+  locale: z4.string().optional().describe("Specific locale to validate (default: all locales)"),
+  fix: z4.boolean().optional().default(false).describe("Auto-fix issues where possible (e.g., remove invalid chars)")
+});
+var jsonSchema4 = toJsonSchema4(validateAsoInputSchema, {
+  name: "ValidateAsoInput",
+  $refStrategy: "none"
+});
+var inputSchema4 = jsonSchema4.definitions?.ValidateAsoInput || jsonSchema4;
+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: inputSchema4
+};
+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/aso/keyword-research.ts
+import fs8 from "fs";
+import path8 from "path";
+import { z as z6 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema6 } from "zod-to-json-schema";
+
+// src/utils/registered-apps.util.ts
+import fs7 from "fs";
+import os from "os";
+import path7 from "path";
+var DEFAULT_REGISTERED_APPS_PATH = path7.join(
+  os.homedir(),
+  ".config",
+  "pabal-mcp",
+  "registered-apps.json"
+);
+function safeReadJson(filePath) {
+  if (!fs7.existsSync(filePath)) return null;
+  try {
+    const raw = fs7.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed?.apps || !Array.isArray(parsed.apps)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function loadRegisteredApps(filePath = DEFAULT_REGISTERED_APPS_PATH) {
+  const data = safeReadJson(filePath);
+  return { apps: data?.apps || [], path: filePath };
+}
+function findRegisteredApp(slug, filePath) {
+  const { apps, path: usedPath } = loadRegisteredApps(filePath);
+  const app = apps.find((a) => a.slug === slug);
+  return { app, path: usedPath };
+}
+function getSupportedLocalesForSlug(slug, platform, filePath) {
+  const { app, path: usedPath } = findRegisteredApp(slug, filePath);
+  if (!app) return { supportedLocales: [], path: usedPath };
+  if (platform === "ios") {
+    return {
+      supportedLocales: app.appStore?.supportedLocales || [],
+      path: usedPath
+    };
+  }
+  return {
+    supportedLocales: app.googlePlay?.supportedLocales || [],
+    path: usedPath
+  };
+}
+
+// src/tools/apps/search.ts
+import { z as z5 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema5 } from "zod-to-json-schema";
+var TOOL_NAME = "search-app";
+var searchAppInputSchema = z5.object({
+  query: z5.string().trim().optional().describe(
+    "Search term (slug, bundleId, packageName, name). Returns all apps if empty."
+  ),
+  store: z5.enum(["all", "appStore", "googlePlay"]).default("all").describe("Store filter (default: all)")
+});
+var jsonSchema5 = zodToJsonSchema5(searchAppInputSchema, {
+  name: "SearchAppInput",
+  $refStrategy: "none"
+});
+var inputSchema5 = jsonSchema5.definitions?.SearchAppInput || jsonSchema5;
+var searchAppTool = {
+  name: TOOL_NAME,
+  description: `Search registered apps from registered-apps.json.
+
+- Called without query: Returns all app list
+- Called with query: Search by slug, bundleId, packageName, name
+- Use store filter to narrow results to appStore or googlePlay only`,
+  inputSchema: inputSchema5
+};
+function matchesQuery(app, query) {
+  const lowerQuery = query.toLowerCase();
+  if (app.slug.toLowerCase().includes(lowerQuery)) return true;
+  if (app.name?.toLowerCase().includes(lowerQuery)) return true;
+  if (app.appStore?.bundleId?.toLowerCase().includes(lowerQuery)) return true;
+  if (app.appStore?.name?.toLowerCase().includes(lowerQuery)) return true;
+  if (app.googlePlay?.packageName?.toLowerCase().includes(lowerQuery))
+    return true;
+  if (app.googlePlay?.name?.toLowerCase().includes(lowerQuery)) return true;
+  return false;
+}
+function filterByStore(apps, store) {
+  if (store === "all") return apps;
+  return apps.filter((app) => {
+    if (store === "appStore") return !!app.appStore;
+    if (store === "googlePlay") return !!app.googlePlay;
+    return true;
+  });
+}
+function formatAppInfo(app) {
+  const lines = [];
+  lines.push(`\u{1F4F1} **${app.name || app.slug}** (\`${app.slug}\`)`);
+  if (app.appStore) {
+    lines.push(`   \u{1F34E} App Store: \`${app.appStore.bundleId || "N/A"}\``);
+    if (app.appStore.appId) {
+      lines.push(`      App ID: ${app.appStore.appId}`);
+    }
+    if (app.appStore.name) {
+      lines.push(`      Name: ${app.appStore.name}`);
+    }
+  }
+  if (app.googlePlay) {
+    lines.push(
+      `   \u{1F916} Google Play: \`${app.googlePlay.packageName || "N/A"}\``
+    );
+    if (app.googlePlay.name) {
+      lines.push(`      Name: ${app.googlePlay.name}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function handleSearchApp(input) {
+  const { query, store = "all" } = input;
+  try {
+    const { apps: allApps, path: configPath } = loadRegisteredApps();
+    let results;
+    if (!query) {
+      results = allApps;
+    } else {
+      const { app: exactMatch } = findRegisteredApp(query);
+      const partialMatches = allApps.filter((app) => matchesQuery(app, query));
+      const seenSlugs = /* @__PURE__ */ new Set();
+      results = [];
+      if (exactMatch && !seenSlugs.has(exactMatch.slug)) {
+        results.push(exactMatch);
+        seenSlugs.add(exactMatch.slug);
+      }
+      for (const app of partialMatches) {
+        if (!seenSlugs.has(app.slug)) {
+          results.push(app);
+          seenSlugs.add(app.slug);
+        }
+      }
+    }
+    results = filterByStore(results, store);
+    if (results.length === 0) {
+      const message = query ? `No apps found matching "${query}".` : "No apps registered.";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u274C ${message}
+
+\u{1F4A1} Register apps in ${configPath}`
+          }
+        ],
+        _meta: { apps: [], count: 0, configPath }
+      };
+    }
+    const header = query ? `\u{1F50D} Search results for "${query}": ${results.length} app(s)` : `\u{1F4CB} Registered app list: ${results.length} app(s)`;
+    const appList = results.map(formatAppInfo).join("\n\n");
+    return {
+      content: [
+        {
+          type: "text",
+          text: `${header}
+
+${appList}
+
+---
+Config: ${configPath}`
+        }
+      ],
+      _meta: { apps: results, count: results.length, configPath }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\u274C App search failed: ${message}`
+        }
+      ]
+    };
+  }
+}
+
+// src/tools/aso/keyword-research.ts
+var TOOL_NAME2 = "keyword-research";
+var keywordResearchInputSchema = z6.object({
+  slug: z6.string().trim().describe("Product slug"),
+  locale: z6.string().trim().describe("Locale code (e.g., en-US, ko-KR). Used for storage under .aso/keywordResearch/products/[slug]/locales/."),
+  platform: z6.enum(["ios", "android"]).default("ios").describe("Store to target ('ios' or 'android'). Run separately per platform."),
+  country: z6.string().length(2).optional().describe(
+    "Two-letter store country code. If omitted, derived from locale region (e.g., ko-KR -> kr), else 'us'."
+  ),
+  seedKeywords: z6.array(z6.string().trim()).default([]).describe("Seed keywords to start from."),
+  competitorApps: z6.array(
+    z6.object({
+      appId: z6.string().trim().describe("App ID (package name or iOS ID/bundle)"),
+      platform: z6.enum(["ios", "android"])
+    })
+  ).default([]).describe("Known competitor apps to probe."),
+  filename: z6.string().trim().optional().describe("Override output filename. Defaults to keyword-research-[platform]-[country].json"),
+  writeTemplate: z6.boolean().default(false).describe("If true, write a JSON template at the output path."),
+  researchData: z6.string().trim().optional().describe(
+    "Optional JSON string with research results (e.g., from mcp-appstore tools). If provided, saves it to the output path."
+  ),
+  researchDataPath: z6.string().trim().optional().describe(
+    "Optional path to a JSON file containing research results. If set, file content is saved to the output path (preferred to avoid escape errors)."
+  )
+});
+var jsonSchema6 = zodToJsonSchema6(keywordResearchInputSchema, {
+  name: "KeywordResearchInput",
+  $refStrategy: "none"
+});
+var inputSchema6 = jsonSchema6.definitions?.KeywordResearchInput || jsonSchema6;
+var keywordResearchTool = {
+  name: TOOL_NAME2,
+  description: `Prep + persist keyword research ahead of improve-public using mcp-appstore outputs.
+
+**IMPORTANT:** Always use 'search-app' tool first to resolve the exact slug before calling this tool. The user may provide an approximate name, bundleId, or packageName - search-app will find and return the correct slug. Never pass user input directly as slug.
+
+## CRITICAL: Multi-Locale Execution Plan
+
+**MANDATORY WORKFLOW - Complete each locale fully before moving to next:**
+
+For EACH locale+platform combination, execute this cycle:
+1. **Plan:** Call keyword-research(slug, locale, platform) with writeTemplate=false \u2192 get research plan
+2. **Research:** Execute COMPLETE mcp-appstore workflow (all 16 steps) for that locale
+3. **Save:** Call keyword-research again with researchData or researchDataPath \u2192 persist actual data
+4. **Next:** Move to next locale+platform and repeat steps 1-3
+
+**IMPORTANT: Research \u2192 Save \u2192 Next pattern**
+- Complete ONE locale fully (research + save) before starting the next
+- This prevents data loss if the session is interrupted
+- Each locale's data is persisted immediately after research
+
+**FORBIDDEN:**
+- \u274C Using writeTemplate=true as final output
+- \u274C Skipping secondary locales
+- \u274C Researching multiple locales then saving all at once at the end
+- \u274C Stopping before all locale+platform combinations are done
+
+**REQUIRED:**
+- \u2705 Research locale \u2192 Save locale \u2192 Move to next (one at a time)
+- \u2705 Run for EVERY platform (ios AND android separately)
+- \u2705 Use researchData or researchDataPath to save (NOT writeTemplate)`,
+  inputSchema: inputSchema6
+};
+function buildTemplate({
+  slug,
+  locale,
+  platform,
+  country,
+  seedKeywords,
+  competitorApps
+}) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    meta: {
+      slug,
+      locale,
+      platform,
+      country,
+      seedKeywords,
+      competitorApps,
+      source: "mcp-appstore",
+      updatedAt: timestamp
+    },
+    plan: {
+      steps: [
+        "1. SETUP: Start mcp-appstore server (node server.js in external-tools/mcp-appstore).",
+        "2. APP IDENTITY: get_app_details(appId) \u2192 confirm exact app name, category, current keywords, and store listing quality.",
+        "3. COMPETITOR DISCOVERY: search_app(term=seed, num=15) + get_similar_apps(appId=your app, num=20) \u2192 identify 5-10 direct competitors (same category, similar size) + 3-5 aspirational competitors (top performers).",
+        "4. COMPETITOR KEYWORD MINING: For top 5 competitors, run suggest_keywords_by_apps \u2192 extract keywords they rank for but you don't.",
+        "5. KEYWORD EXPANSION (run ALL, num=30 each): suggest_keywords_by_seeds (your app name + core features), by_category (your primary category), by_similarity (semantic variations), by_competition (gap analysis), by_search (autocomplete/trending).",
+        "6. KEYWORD SCORING: get_keyword_scores for ALL candidates (50-100 keywords) \u2192 filter by: traffic \u226510, difficulty \u226470, relevance to your app.",
+        "7. REVIEW INTELLIGENCE: analyze_reviews(num=200) + fetch_reviews(num=100) on top 3 competitors \u2192 extract: user pain points, feature requests, emotional language, native phrases users actually use.",
+        "8. KEYWORD CATEGORIZATION: Group into tiers - Tier1 (3-5): high traffic (\u22651000), high relevance, moderate difficulty (\u226450); Tier2 (5-7): medium traffic (100-1000), exact feature match; Tier3 (5-8): longtail (<100 traffic), very low difficulty (\u226430), high conversion intent.",
+        "9. LOCALIZATION CHECK: Verify keywords are natural in target locale - avoid direct translations, prefer native expressions found in reviews.",
+        "10. GAP ANALYSIS: Compare your current keywords vs competitor keywords \u2192 identify missed opportunities and over-saturated terms to avoid.",
+        "11. VALIDATION: For final 15-20 keywords, ensure each has: score data, clear user intent, natural locale fit, and specific rationale for inclusion.",
+        "Keep rationale/nextActions in English by default unless you intentionally localize them."
+      ],
+      selectionCriteria: {
+        tier1_core: "High traffic (\u22651000), relevance score \u22650.8, difficulty \u226450, brand-safe",
+        tier2_feature: "Medium traffic (100-1000), exact feature/benefit match, difficulty \u226460",
+        tier3_longtail: "Low traffic (<100), very low difficulty (\u226430), high purchase/download intent phrases",
+        avoid: "Generic terms (difficulty \u226580), irrelevant categories, competitor brand names, terms with no search volume"
+      },
+      qualityChecks: [
+        "Each keyword has traffic + difficulty scores (no gaps)",
+        "Mix of 3 tiers represented (not all longtail, not all high-competition)",
+        "Keywords validated against actual user language from reviews",
+        "No duplicate semantic meanings (e.g., 'photo edit' and 'edit photo')",
+        "Locale-appropriate phrasing verified"
+      ],
+      note: "Run per platform/country. Target 15-20 keywords per locale with clear tier distribution. Save ALL raw data for audit trail."
+    },
+    data: {
+      raw: {
+        searchApp: [],
+        getAppDetails: [],
+        similarApps: [],
+        keywordSuggestions: {
+          bySeeds: [],
+          byCategory: [],
+          bySimilarity: [],
+          byCompetition: [],
+          bySearchHints: [],
+          byApps: []
+        },
+        keywordScores: [],
+        reviewsAnalysis: [],
+        reviewsRaw: []
+      },
+      summary: {
+        recommendedKeywords: [],
+        keywordsByTier: {
+          tier1_core: [],
+          tier2_feature: [],
+          tier3_longtail: []
+        },
+        competitorInsights: {
+          topCompetitors: [],
+          keywordGaps: [],
+          userLanguagePatterns: []
+        },
+        rationale: "",
+        confidence: {
+          dataQuality: "",
+          localeRelevance: "",
+          competitivePosition: ""
+        },
+        nextActions: [
+          "Feed tiered keywords into improve-public Stage 1 (prioritize Tier1 for title, Tier2-3 for keyword field)",
+          "Monitor keyword rankings post-update",
+          "Re-run research quarterly or after major competitor changes"
+        ]
+      }
+    }
+  };
+}
+function saveJsonFile({
+  researchDir,
+  fileName,
+  payload
+}) {
+  fs8.mkdirSync(researchDir, { recursive: true });
+  const outputPath = path8.join(researchDir, fileName);
+  fs8.writeFileSync(outputPath, JSON.stringify(payload, null, 2) + "\n", "utf-8");
+  return outputPath;
+}
+function normalizeKeywords(raw) {
+  if (!raw) return [];
+  if (Array.isArray(raw)) {
+    return raw.map((k) => k.trim()).filter((k) => k.length > 0);
+  }
+  return raw.split(",").map((k) => k.trim()).filter((k) => k.length > 0);
+}
+async function handleKeywordResearch(input) {
+  const {
+    slug,
+    locale,
+    platform = "ios",
+    country,
+    seedKeywords = [],
+    competitorApps = [],
+    filename,
+    writeTemplate = false,
+    researchData,
+    researchDataPath
+  } = input;
+  const searchResult = await handleSearchApp({ query: slug, store: "all" });
+  const registeredApps = searchResult._meta?.apps || [];
+  const registeredApp = registeredApps.length > 0 ? registeredApps[0] : void 0;
+  const { config, locales } = loadProductLocales(slug);
+  const primaryLocale = resolvePrimaryLocale(config, locales);
+  const productLocales = Object.keys(locales);
+  const primaryLocaleData = locales[primaryLocale];
+  const { supportedLocales, path: supportedPath } = getSupportedLocalesForSlug(slug, platform);
+  const appStoreLocales = registeredApp?.appStore?.supportedLocales || [];
+  const googlePlayLocales = registeredApp?.googlePlay?.supportedLocales || [];
+  const declaredPlatforms = [
+    registeredApp?.appStore ? "ios" : null,
+    registeredApp?.googlePlay ? "android" : null
+  ].filter(Boolean);
+  const autoSeeds = [];
+  const autoCompetitors = [];
+  if (primaryLocaleData?.aso?.title) {
+    autoSeeds.push(primaryLocaleData.aso.title);
+  }
+  const parsedKeywords = normalizeKeywords(primaryLocaleData?.aso?.keywords);
+  autoSeeds.push(...parsedKeywords.slice(0, 5));
+  if (config?.name) autoSeeds.push(config.name);
+  if (config?.tagline) autoSeeds.push(config.tagline);
+  if (!config?.name && registeredApp?.name) autoSeeds.push(registeredApp.name);
+  if (!primaryLocaleData?.aso?.title) {
+    if (platform === "ios" && registeredApp?.appStore?.name) {
+      autoSeeds.push(registeredApp.appStore.name);
+    }
+    if (platform === "android" && registeredApp?.googlePlay?.name) {
+      autoSeeds.push(registeredApp.googlePlay.name);
+    }
+  }
+  if (platform === "ios") {
+    if (config?.appStoreAppId) {
+      autoCompetitors.push({ appId: String(config.appStoreAppId), platform });
+    } else if (config?.bundleId) {
+      autoCompetitors.push({ appId: config.bundleId, platform });
+    } else if (registeredApp?.appStore?.appId) {
+      autoCompetitors.push({
+        appId: String(registeredApp.appStore.appId),
+        platform
+      });
+    } else if (registeredApp?.appStore?.bundleId) {
+      autoCompetitors.push({
+        appId: registeredApp.appStore.bundleId,
+        platform
+      });
+    }
+  } else if (platform === "android" && config?.packageName) {
+    autoCompetitors.push({ appId: config.packageName, platform });
+  } else if (platform === "android" && registeredApp?.googlePlay?.packageName) {
+    autoCompetitors.push({
+      appId: registeredApp.googlePlay.packageName,
+      platform
+    });
+  }
+  const resolvedSeeds = seedKeywords.length > 0 ? seedKeywords : Array.from(new Set(autoSeeds));
+  const resolvedCompetitors = competitorApps.length > 0 ? competitorApps : autoCompetitors;
+  const resolvedCountry = country || (locale?.includes("-") ? locale.split("-")[1].toLowerCase() : "us");
+  const researchDir = path8.join(
+    getKeywordResearchDir(),
+    "products",
+    slug,
+    "locales",
+    locale
+  );
+  const defaultFileName = `keyword-research-${platform}-${resolvedCountry}.json`;
+  const fileName = filename || defaultFileName;
+  let outputPath = path8.join(researchDir, fileName);
+  let fileAction;
+  const parseJsonWithContext = (text) => {
+    try {
+      return JSON.parse(text);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const match = /position (\d+)/i.exec(message) || /column (\d+)/i.exec(message) || /char (\d+)/i.exec(message);
+      if (match) {
+        const pos = Number(match[1]);
+        const start = Math.max(0, pos - 40);
+        const end = Math.min(text.length, pos + 40);
+        const context = text.slice(start, end);
+        throw new Error(
+          `Failed to parse researchData JSON: ${message}
+Context around ${pos}: ${context}`
+        );
+      }
+      throw new Error(`Failed to parse researchData JSON: ${message}`);
+    }
+  };
+  const loadResearchDataFromPath = (p) => {
+    if (!fs8.existsSync(p)) {
+      throw new Error(`researchDataPath not found: ${p}`);
+    }
+    const raw = fs8.readFileSync(p, "utf-8");
+    return parseJsonWithContext(raw);
+  };
+  if (writeTemplate || researchData) {
+    const payload = researchData ? parseJsonWithContext(researchData) : researchDataPath ? loadResearchDataFromPath(researchDataPath) : buildTemplate({
+      slug,
+      locale,
+      platform,
+      country: resolvedCountry,
+      seedKeywords: resolvedSeeds,
+      competitorApps: resolvedCompetitors
+    });
+    outputPath = saveJsonFile({ researchDir, fileName, payload });
+    fileAction = researchData ? "Saved provided researchData" : "Wrote template";
+  }
+  const templatePreview = JSON.stringify(
+    buildTemplate({
+      slug,
+      locale,
+      platform,
+      country: resolvedCountry,
+      seedKeywords: resolvedSeeds,
+      competitorApps: resolvedCompetitors
+    }),
+    null,
+    2
+  );
+  const lines = [];
+  lines.push(`# Keyword research plan (${slug})`);
+  lines.push(`Locale: ${locale} | Platform: ${platform} | Country: ${resolvedCountry}`);
+  lines.push(`Primary locale detected: ${primaryLocale}`);
+  if (declaredPlatforms.length > 0) {
+    lines.push(`Supported platforms (search-app): ${declaredPlatforms.join(", ")}`);
+  } else {
+    lines.push("Supported platforms (search-app): none detected\u2014update registered-apps.json");
+  }
+  if (appStoreLocales.length > 0) {
+    lines.push(`Declared App Store locales: ${appStoreLocales.join(", ")}`);
+  }
+  if (googlePlayLocales.length > 0) {
+    lines.push(`Declared Google Play locales: ${googlePlayLocales.join(", ")}`);
+  }
+  if (supportedLocales.length > 0) {
+    lines.push(
+      `Registered supported locales (${platform}): ${supportedLocales.join(
+        ", "
+      )} (source: ${supportedPath})`
+    );
+    if (!supportedLocales.includes(locale)) {
+      lines.push(
+        `WARNING: locale ${locale} not in registered supported locales. Confirm this locale or update registered-apps.json.`
+      );
+    }
+  } else {
+    lines.push(
+      `Registered supported locales not found for ${platform} (checked: ${supportedPath}).`
+    );
+  }
+  const allCombinations = [];
+  const platformsToRun = declaredPlatforms.length > 0 ? declaredPlatforms : [platform];
+  for (const plat of platformsToRun) {
+    for (const loc of productLocales.length > 0 ? productLocales : [locale]) {
+      allCombinations.push({ loc, plat });
+    }
+  }
+  const currentIndex = allCombinations.findIndex(
+    (c) => c.loc === locale && c.plat === platform
+  );
+  const completedCount = currentIndex >= 0 ? currentIndex : 0;
+  const remainingCombinations = allCombinations.slice(currentIndex + 1);
+  if (productLocales.length > 0) {
+    lines.push(
+      `Existing product locales (${productLocales.length}): ${productLocales.join(", ")}`
+    );
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push("## \u{1F3AF} EXECUTION PROGRESS TRACKER");
+  lines.push("");
+  lines.push(`**Total combinations to complete:** ${allCombinations.length} (${platformsToRun.length} platforms \xD7 ${productLocales.length || 1} locales)`);
+  lines.push(`**Current:** ${locale} + ${platform} (${completedCount + 1}/${allCombinations.length})`);
+  lines.push("");
+  if (researchData || researchDataPath) {
+    lines.push(`\u2705 SAVED: ${locale} + ${platform} - Full research data persisted`);
+  } else if (writeTemplate) {
+    lines.push(`\u26A0\uFE0F WARNING: ${locale} + ${platform} - Only template written! You MUST run full mcp-appstore research and save actual data.`);
+  } else {
+    lines.push(`\u{1F4CB} PLANNING: ${locale} + ${platform} - Research plan shown. Now execute mcp-appstore workflow.`);
+  }
+  if (remainingCombinations.length > 0) {
+    lines.push("");
+    lines.push("## \u23ED\uFE0F MANDATORY NEXT STEPS");
+    lines.push("");
+    lines.push("**After completing current locale+platform, you MUST continue with:**");
+    lines.push("");
+    remainingCombinations.forEach((combo, idx) => {
+      lines.push(`${idx + 1}. keyword-research(slug="${slug}", locale="${combo.loc}", platform="${combo.plat}") \u2192 full mcp-appstore workflow \u2192 save results`);
+    });
+    lines.push("");
+    lines.push("\u26D4 DO NOT mark this task as complete until ALL combinations above have FULL research data (not templates).");
+  } else {
+    lines.push("");
+    lines.push("## \u2705 FINAL STEP");
+    lines.push("");
+    lines.push("This is the LAST locale+platform combination. After saving full research data for this one, the task is complete.");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(
+    `Seeds: ${resolvedSeeds.length > 0 ? resolvedSeeds.join(", ") : "(none set; add seedKeywords or ensure ASO keywords/title exist)"}`
+  );
+  lines.push(
+    `Competitors (from config if empty): ${resolvedCompetitors.length > 0 ? resolvedCompetitors.map((c) => `${c.platform}:${c.appId}`).join(", ") : "(none set; add competitorApps or set appStoreAppId/bundleId/packageName in config.json)"}`
+  );
+  lines.push("");
+  lines.push("## Research Workflow (mcp-appstore)");
+  lines.push("");
+  lines.push("### Phase 1: Setup & Discovery");
+  lines.push(
+    `1) Start mcp-appstore server: node server.js (cwd: external-tools/mcp-appstore)`
+  );
+  lines.push(
+    `2) get_app_details(appId) \u2192 confirm app identity, category, current metadata`
+  );
+  lines.push(
+    `3) search_app(term=seed, num=15, platform=${platform}, country=${resolvedCountry}) \u2192 find direct competitors`
+  );
+  lines.push(
+    `4) get_similar_apps(appId=your app, num=20) \u2192 discover related apps in your space`
+  );
+  lines.push("");
+  lines.push("### Phase 2: Keyword Mining (run ALL of these)");
+  lines.push(
+    `5) suggest_keywords_by_apps(apps=[top 5 competitors]) \u2192 steal competitor keywords`
+  );
+  lines.push(
+    `6) suggest_keywords_by_seeds(seeds=[app name, core features], num=30)`
+  );
+  lines.push(
+    `7) suggest_keywords_by_category(category=your primary category, num=30)`
+  );
+  lines.push(
+    `8) suggest_keywords_by_similarity + by_competition + by_search (num=30 each)`
+  );
+  lines.push("");
+  lines.push("### Phase 3: Scoring & Filtering");
+  lines.push(
+    `9) get_keyword_scores for ALL candidates (50-100 keywords) \u2192 get traffic & difficulty`
+  );
+  lines.push(
+    `10) Filter: traffic \u226510, difficulty \u226470, relevant to your app's core value`
+  );
+  lines.push("");
+  lines.push("### Phase 4: User Language Intelligence");
+  lines.push(
+    `11) analyze_reviews(appId=top 3 competitors, num=200) \u2192 sentiment & themes`
+  );
+  lines.push(
+    `12) fetch_reviews(appId=top 3 competitors, num=100) \u2192 extract exact phrases users say`
+  );
+  lines.push(
+    `13) Cross-reference keywords with review language \u2192 validate natural phrasing`
+  );
+  lines.push("");
+  lines.push("### Phase 5: Final Selection");
+  lines.push(
+    `14) Categorize into tiers: Tier1 (3-5 high-traffic core), Tier2 (5-7 feature-match), Tier3 (5-8 longtail)`
+  );
+  lines.push(
+    `15) Validate each keyword has: score, intent, locale fit, inclusion rationale`
+  );
+  lines.push(
+    `16) Save to: ${outputPath}`
+  );
+  lines.push("");
+  lines.push("### Quality Checklist");
+  lines.push("- [ ] 15-20 keywords with complete score data");
+  lines.push("- [ ] All 3 tiers represented (not just longtail)");
+  lines.push("- [ ] Keywords validated against actual review language");
+  lines.push("- [ ] No semantic duplicates");
+  lines.push("- [ ] Locale-appropriate (not direct translations)");
+  if (fileAction) {
+    lines.push(`File: ${fileAction} at ${outputPath}`);
+    if (writeTemplate && !researchData && !researchDataPath) {
+      lines.push(
+        "\u26A0\uFE0F Template is a placeholder\u2014replace with FULL mcp-appstore research results for this locale (no template-only coverage)."
+      );
+    }
+  } else {
+    lines.push(
+      `Tip: set writeTemplate=true to create the JSON skeleton at ${outputPath} (still run full research per locale)`
+    );
+  }
+  lines.push("");
+  lines.push("Suggested JSON shape:");
+  lines.push("```json");
+  lines.push(templatePreview);
+  lines.push("```");
+  return {
+    content: [
+      {
+        type: "text",
+        text: lines.join("\n")
+      }
+    ]
+  };
+}
+
+// src/tools/apps/init.ts
+import fs9 from "fs";
+import path9 from "path";
+import { z as z7 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema7 } 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);
+};
+var initProjectInputSchema = z7.object({
+  slug: z7.string().trim().optional().describe(
+    "Optional product slug to focus on. Defaults to all slugs in .aso/pullData/products/"
+  )
+});
+var jsonSchema7 = zodToJsonSchema7(initProjectInputSchema, {
+  name: "InitProjectInput",
+  $refStrategy: "none"
+});
+var inputSchema7 = jsonSchema7.definitions?.InitProjectInput || jsonSchema7;
+var initProjectTool = {
+  name: "init-project",
+  description: `Guides the initialization flow: run pabal-mcp Init, then convert ASO pullData into public/products/[slug]/.
+
+This tool is read-only and returns a checklist. It does not call pabal-mcp directly or write files.
+
+Steps:
+1) Ensure pabal-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-web-mcp tools (aso-to-public, public-to-aso dry run)
+3) Validate outputs and next actions`,
+  inputSchema: inputSchema7
+};
+async function handleInitProject(input) {
+  const pullDataDir = path9.join(getPullDataDir(), "products");
+  const publicDir = getProductsDir();
+  const pullDataSlugs = listSlugDirs(pullDataDir);
+  const publicSlugs = listSlugDirs(publicDir);
+  const targetSlugs = input.slug?.length && input.slug.trim().length > 0 ? [input.slug.trim()] : pullDataSlugs.length > 0 ? pullDataSlugs : publicSlugs;
+  const lines = [];
+  lines.push("Init workflow (pabal-mcp -> pabal-web-mcp)");
+  lines.push(
+    `Target slugs: ${targetSlugs.length > 0 ? targetSlugs.join(", ") : "(none detected)"}`
+  );
+  lines.push(
+    `pullData: ${pullDataSlugs.length > 0 ? "found" : "missing"} at ${pullDataDir}`
+  );
+  lines.push(
+    `public/products: ${publicSlugs.length > 0 ? "found" : "missing"} at ${publicDir}`
+  );
+  lines.push("");
+  if (targetSlugs.length === 0) {
+    lines.push(
+      "No products detected. Run pabal-mcp 'init' for your slug(s) to populate .aso/pullData/products/, then rerun this tool."
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: lines.join("\n")
+        }
+      ]
+    };
+  }
+  lines.push("Step 1: Fetch raw ASO data (pabal-mcp 'init')");
+  for (const slug of targetSlugs) {
+    const hasPull = pullDataSlugs.includes(slug);
+    lines.push(`- ${slug}: ${hasPull ? "pullData ready" : "pullData missing"}`);
+  }
+  lines.push(
+    "Action: In pabal-mcp, run the 'init' tool for each slug above that is missing pullData."
+  );
+  lines.push("");
+  lines.push(
+    "Step 2: Convert pullData to web assets (pabal-web-mcp 'aso-to-public')"
+  );
+  for (const slug of targetSlugs) {
+    const hasPull = pullDataSlugs.includes(slug);
+    const hasPublic = publicSlugs.includes(slug);
+    const pullStatus = hasPull ? "pullData ready" : "pullData missing";
+    const publicStatus = hasPublic ? "public/products ready" : "public/products missing";
+    lines.push(
+      `- ${slug}: ${pullStatus}, ${publicStatus}${hasPull && !hasPublic ? " (ready to convert)" : ""}`
+    );
+  }
+  lines.push(
+    "Action: After pullData exists, run pabal-web-mcp 'aso-to-public' per slug to generate locale prompts. Save results to public/products/[slug]/locales/, copy screenshots, and ensure config.json/icon/og-image are in place."
+  );
+  lines.push("");
+  lines.push("Step 3: Verify and prepare for push (optional)");
+  lines.push(
+    "Use pabal-web-mcp 'public-to-aso' with dryRun=true to validate structure and build pushData before uploading via store tooling."
+  );
+  lines.push("");
+  lines.push("Notes:");
+  lines.push(
+    "- This tool is read-only; it does not write files or call pabal-mcp."
+  );
+  lines.push(
+    "- Extend this init checklist as new processes are added (e.g., asset generation or validations)."
+  );
+  return {
+    content: [
+      {
+        type: "text",
+        text: lines.join("\n")
+      }
+    ]
+  };
+}
+
+// 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";
+
+// src/utils/blog.util.ts
+import fs10 from "fs";
+import path10 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, "");
+var compact = (items) => (items || []).filter((item) => Boolean(item && item.trim()));
+function slugifyTitle(title) {
+  const normalized = removeDiacritics(title).toLowerCase().replace(/[^a-z0-9\s-]/g, " ").replace(/[_\s]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || "post";
+}
+function normalizeDate(date) {
+  if (date) {
+    if (!DATE_REGEX.test(date)) {
+      throw new Error(
+        `Invalid date format "${date}". Use YYYY-MM-DD (e.g. 2024-09-30).`
+      );
+    }
+    return date;
+  }
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+var toPublicBlogBase = (appSlug, slug) => `/${BLOG_ROOT}/${appSlug}/${slug}`;
+function resolveCoverImagePath(appSlug, slug, coverImage) {
+  if (!coverImage || !coverImage.trim()) {
+    return `/products/${appSlug}/og-image.png`;
+  }
+  const cleaned = coverImage.trim();
+  const relativePath = cleaned.replace(/^\.\//, "");
+  if (!cleaned.startsWith("/") && !/^https?:\/\//.test(cleaned)) {
+    return `${toPublicBlogBase(appSlug, slug)}/${relativePath}`;
+  }
+  if (cleaned.startsWith("./")) {
+    return `${toPublicBlogBase(appSlug, slug)}/${relativePath}`;
+  }
+  return cleaned;
+}
+function deriveTags(topic, appSlug) {
+  const topicParts = topic.toLowerCase().split(/[^a-z0-9+]+/).filter(Boolean).slice(0, 6);
+  const set = /* @__PURE__ */ new Set([...topicParts, appSlug.toLowerCase(), "blog"]);
+  return Array.from(set);
+}
+function buildBlogMeta(options) {
+  const publishedAt = normalizeDate(options.publishedAt);
+  const modifiedAt = normalizeDate(options.modifiedAt || publishedAt);
+  const coverImage = resolveCoverImagePath(
+    options.appSlug,
+    options.slug,
+    options.coverImage
+  );
+  if (!options.description || !options.description.trim()) {
+    throw new Error(
+      "Description is required. The LLM must generate a meta description based on the topic and locale."
+    );
+  }
+  return {
+    title: options.title,
+    description: options.description.trim(),
+    appSlug: options.appSlug,
+    slug: options.slug,
+    locale: options.locale,
+    publishedAt,
+    modifiedAt,
+    coverImage,
+    tags: compact(options.tags)?.length ? Array.from(
+      new Set(compact(options.tags).map((tag) => tag.toLowerCase()))
+    ) : deriveTags(options.topic, options.appSlug)
+  };
+}
+function renderBlogMetaBlock(meta) {
+  const serialized = JSON.stringify(meta, null, 2);
+  return `<!--BLOG_META
+${serialized}
+-->`;
+}
+function buildBlogHtmlDocument(options) {
+  const metaBlock = renderBlogMetaBlock(options.meta);
+  const body = options.content.trim();
+  return `${metaBlock}
+${body}`;
+}
+function resolveTargetLocales(input) {
+  if (input.locales?.length) {
+    const locales = input.locales.map((loc) => loc.trim()).filter(Boolean);
+    return Array.from(new Set(locales));
+  }
+  const fallback = input.locale?.trim();
+  return fallback ? [fallback] : [];
+}
+function getBlogOutputPaths(options) {
+  const baseDir = path10.join(
+    options.publicDir,
+    BLOG_ROOT,
+    options.appSlug,
+    options.slug
+  );
+  const filePath = path10.join(baseDir, `${options.locale}.html`);
+  const publicBasePath = toPublicBlogBase(options.appSlug, options.slug);
+  return { baseDir, filePath, publicBasePath };
+}
+function parseBlogHtml(htmlContent) {
+  const metaBlockRegex = /<!--BLOG_META\s*\n([\s\S]*?)\n-->/;
+  const match = htmlContent.match(metaBlockRegex);
+  if (!match) {
+    return { meta: null, body: htmlContent.trim() };
+  }
+  try {
+    const metaJson = match[1].trim();
+    const meta = JSON.parse(metaJson);
+    const body = htmlContent.replace(metaBlockRegex, "").trim();
+    return { meta, body };
+  } catch (error) {
+    return { meta: null, body: htmlContent.trim() };
+  }
+}
+function findExistingBlogPosts({
+  appSlug,
+  locale,
+  publicDir,
+  limit = 2
+}) {
+  const blogAppDir = path10.join(publicDir, BLOG_ROOT, appSlug);
+  if (!fs10.existsSync(blogAppDir)) {
+    return [];
+  }
+  const posts = [];
+  const subdirs = fs10.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;
+    try {
+      const htmlContent = fs10.readFileSync(localeFile, "utf-8");
+      const { meta, body } = parseBlogHtml(htmlContent);
+      if (meta && meta.locale === locale) {
+        posts.push({
+          filePath: localeFile,
+          meta,
+          body,
+          publishedAt: meta.publishedAt
+        });
+      }
+    } catch (error) {
+      continue;
+    }
+  }
+  posts.sort((a, b) => {
+    const dateA = new Date(a.publishedAt).getTime();
+    const dateB = new Date(b.publishedAt).getTime();
+    return dateB - dateA;
+  });
+  return posts.slice(0, limit).map(({ filePath, meta, body }) => ({
+    filePath,
+    meta,
+    body
+  }));
+}
+
+// src/tools/content/create-blog-html.ts
+var toJsonSchema5 = zodToJsonSchema8;
+var DATE_REGEX2 = /^\d{4}-\d{2}-\d{2}$/;
+var createBlogHtmlInputSchema = z8.object({
+  appSlug: z8.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(
+    "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(
+    "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(
+    "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(
+    "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(
+    "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(
+    "Optional tags for BLOG_META. Defaults to tags derived from topic."
+  ),
+  coverImage: z8.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).")
+}).describe("Generate static HTML blog posts with BLOG_META headers.");
+var jsonSchema8 = toJsonSchema5(createBlogHtmlInputSchema, {
+  name: "CreateBlogHtmlInput",
+  $refStrategy: "none"
+});
+var inputSchema8 = jsonSchema8.definitions?.CreateBlogHtmlInput || jsonSchema8;
+var createBlogHtmlTool = {
+  name: "create-blog-html",
+  description: `Generate HTML blog posts under public/blogs/<appSlug>/<slug>/<locale>.html with a BLOG_META block.
+
+CRITICAL: WRITING STYLE CONSISTENCY
+Before generating content, you MUST:
+1. Read existing blog posts from public/blogs/<appSlug>/*/<locale>.html (use findExistingBlogPosts utility or read files directly)
+2. Analyze the writing style, tone, and format from 2 existing posts in the same locale
+3. Match that exact writing style when generating the new blog post content and description
+4. Maintain consistency in: paragraph structure, heading usage, tone, formality level, and overall format
+
+IMPORTANT REQUIREMENTS:
+1. The 'locale' parameter is REQUIRED. If the user does not provide a locale, you MUST ask them to specify which language/locale they want to write the blog in (e.g., 'en-US', 'ko-KR', 'ja-JP', etc.).
+2. The 'content' parameter is REQUIRED. You (the LLM) must generate the HTML content based on the 'topic' and 'locale' provided by the user. The content should be written in the language corresponding to the locale AND match the writing style of existing blog posts for that locale.
+3. The 'description' parameter is REQUIRED. You (the LLM) must generate this based on the topic, locale, AND the writing style of existing blog posts.
+4. The 'appSlug' parameter: 
+   - If the user explicitly requests "developer category", "developer blog", "personal category", "my category", or similar, you MUST set appSlug to "developer".
+   - If the user mentions a specific app/product, use that app's slug.
+   - If not specified, defaults to "developer".
+
+Slug rules:
+- slug = slugify(English title, kebab-case ASCII)
+- path: public/blogs/<appSlug>/<slug>/<locale>.html
+- appSlug: Use "developer" when user requests developer/personal category. Defaults to "developer" if not specified.
+- coverImage default: /products/<appSlug>/og-image.png (relative paths are rewritten under /blogs/<app>/<slug>/)
+- overwrite defaults to false (throws when file exists)
+
+HTML Structure (follows public/en-US.html pattern):
+- BLOG_META block at the top with JSON metadata
+- HTML body content: paragraphs (<p>), headings (<h2>, <h3>), images (<img>), lists (<ul>, <li>), horizontal rules (<hr>), etc.
+- You must generate the HTML content based on the topic, making it relevant and engaging for the target locale's language, while maintaining consistency with existing blog posts.
+
+Supports multiple locales when locales[] is provided. Each locale gets its own HTML file. For each locale, you must:
+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
+};
+async function handleCreateBlogHtml(input) {
+  const publicDir = getPublicDir();
+  const {
+    appSlug = DEFAULT_APP_SLUG,
+    topic,
+    title,
+    description,
+    tags,
+    coverImage,
+    publishedAt,
+    modifiedAt,
+    overwrite = false,
+    content
+  } = input;
+  if (!content || !content.trim()) {
+    throw new Error(
+      "Content is required. Please provide HTML content for the blog body based on the topic and locale."
+    );
+  }
+  const resolvedTitle = title && title.trim() || topic.trim();
+  const slug = slugifyTitle(resolvedTitle);
+  const targetLocales = resolveTargetLocales(input);
+  if (!targetLocales.length) {
+    throw new Error(
+      "Locale is required. Please specify which language/locale you want to write the blog in (e.g., 'en-US', 'ko-KR', 'ja-JP')."
+    );
+  }
+  const existingPostsByLocale = {};
+  for (const locale of targetLocales) {
+    const existingPosts = findExistingBlogPosts({
+      appSlug,
+      locale,
+      publicDir,
+      limit: 2
+    });
+    if (existingPosts.length > 0) {
+      existingPostsByLocale[locale] = existingPosts;
+    }
+  }
+  const output = {
+    slug,
+    baseDir: path11.join(publicDir, "blogs", appSlug, slug),
+    files: [],
+    coverImage: coverImage && coverImage.trim().length > 0 ? coverImage.trim() : `/products/${appSlug}/og-image.png`,
+    metaByLocale: {}
+  };
+  const plannedFiles = targetLocales.map(
+    (locale) => getBlogOutputPaths({
+      appSlug,
+      slug,
+      locale,
+      publicDir
+    })
+  );
+  const existing = plannedFiles.filter(
+    ({ filePath }) => fs11.existsSync(filePath)
+  );
+  if (existing.length > 0 && !overwrite) {
+    const existingList = existing.map((f) => f.filePath).join("\n- ");
+    throw new Error(
+      `Blog HTML already exists. Set overwrite=true to replace:
+- ${existingList}`
+    );
+  }
+  fs11.mkdirSync(output.baseDir, { recursive: true });
+  for (const locale of targetLocales) {
+    const { filePath } = getBlogOutputPaths({
+      appSlug,
+      slug,
+      locale,
+      publicDir
+    });
+    const meta = buildBlogMeta({
+      title: resolvedTitle,
+      description,
+      appSlug,
+      slug,
+      locale,
+      topic,
+      coverImage,
+      tags,
+      publishedAt,
+      modifiedAt
+    });
+    output.coverImage = meta.coverImage;
+    output.metaByLocale[locale] = meta;
+    const html = buildBlogHtmlDocument({
+      meta,
+      content
+    });
+    fs11.writeFileSync(filePath, html, "utf-8");
+    output.files.push({ locale, path: filePath });
+  }
+  const summaryLines = [
+    `Created blog HTML for ${appSlug}`,
+    `Slug: ${slug}`,
+    `Locales: ${targetLocales.join(", ")}`,
+    `Cover image: ${output.coverImage}`,
+    "",
+    "Files:",
+    ...output.files.map((file) => `- ${file.locale}: ${file.path}`)
+  ];
+  const styleReferenceInfo = [];
+  for (const [locale, posts] of Object.entries(existingPostsByLocale)) {
+    if (posts.length > 0) {
+      styleReferenceInfo.push(
+        `
+Writing style reference for ${locale}: Found ${posts.length} existing post(s) used for style consistency.`
+      );
+    }
+  }
+  if (styleReferenceInfo.length === 0) {
+    styleReferenceInfo.push(
+      "\nNote: No existing blog posts found for style reference. This is the first post for this app/locale combination."
+    );
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: summaryLines.join("\n") + styleReferenceInfo.join("")
+      }
+    ]
+  };
+}
+
+// src/tools/index.ts
+var tools = [
+  // ASO Tools
+  {
+    name: asoToPublicTool.name,
+    description: asoToPublicTool.description,
+    inputSchema: asoToPublicTool.inputSchema,
+    zodSchema: asoToPublicInputSchema,
+    handler: handleAsoToPublic,
+    category: "aso"
+  },
+  {
+    name: publicToAsoTool.name,
+    description: publicToAsoTool.description,
+    inputSchema: publicToAsoTool.inputSchema,
+    zodSchema: publicToAsoInputSchema,
+    handler: handlePublicToAso,
+    category: "aso"
+  },
+  {
+    name: improvePublicTool.name,
+    description: improvePublicTool.description,
+    inputSchema: improvePublicTool.inputSchema,
+    zodSchema: improvePublicInputSchema,
+    handler: handleImprovePublic,
+    category: "aso"
+  },
+  {
+    name: validateAsoTool.name,
+    description: validateAsoTool.description,
+    inputSchema: validateAsoTool.inputSchema,
+    zodSchema: validateAsoInputSchema,
+    handler: handleValidateAso,
+    category: "aso"
+  },
+  {
+    name: keywordResearchTool.name,
+    description: keywordResearchTool.description,
+    inputSchema: keywordResearchTool.inputSchema,
+    zodSchema: keywordResearchInputSchema,
+    handler: handleKeywordResearch,
+    category: "aso"
+  },
+  // Apps Tools
+  {
+    name: initProjectTool.name,
+    description: initProjectTool.description,
+    inputSchema: initProjectTool.inputSchema,
+    zodSchema: initProjectInputSchema,
+    handler: handleInitProject,
+    category: "apps"
+  },
+  {
+    name: searchAppTool.name,
+    description: searchAppTool.description,
+    inputSchema: searchAppTool.inputSchema,
+    zodSchema: searchAppInputSchema,
+    handler: handleSearchApp,
+    category: "apps"
+  },
+  // Content Tools
+  {
+    name: createBlogHtmlTool.name,
+    description: createBlogHtmlTool.description,
+    inputSchema: createBlogHtmlTool.inputSchema,
+    zodSchema: createBlogHtmlInputSchema,
+    handler: handleCreateBlogHtml,
+    category: "content"
+  }
+];
+function getToolDefinitions() {
+  return [
+    asoToPublicTool,
+    publicToAsoTool,
+    improvePublicTool,
+    initProjectTool,
+    createBlogHtmlTool,
+    keywordResearchTool,
+    searchAppTool,
+    validateAsoTool
+  ];
+}
+function getToolHandler(name) {
+  const tool = tools.find((t) => t.name === name);
+  if (!tool) {
+    throw new Error(`Unknown tool: ${name}`);
+  }
+  return tool.handler;
+}
+function getToolZodSchema(name) {
+  const tool = tools.find((t) => t.name === name);
+  if (!tool) {
+    throw new Error(`Unknown tool: ${name}`);
+  }
+  return tool.zodSchema;
+}
+
+// src/bin/mcp-server.ts
+var server = new Server(
+  {
+    name: "pabal-web-mcp",
+    version: "0.1.0"
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: getToolDefinitions()
+  };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const zodSchema = getToolZodSchema(name);
+  const handler = getToolHandler(name);
+  if (!zodSchema) {
+    throw new Error(`No schema found for tool: ${name}`);
+  }
+  const input = zodSchema.parse(args);
+  return await handler(input);
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("pabal-web-mcp server running on stdio");
+}
+main().catch((error) => {
+  console.error("Fatal error in main():", error);
+  process.exit(1);
+});