pabal-web-mcp 0.1.0

package/dist/bin/mcp-server.js

@@ -0,0 +1,1906 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_LOCALE,
+  appStoreToUnified,
+  googlePlayToUnified,
+  isAppStoreMultilingual,
+  isGooglePlayMultilingual,
+  loadAsoFromConfig,
+  saveAsoToAsoDir,
+  unifiedToAppStore,
+  unifiedToGooglePlay
+} from "../chunk-YJWGBO7W.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-to-public.ts
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// src/tools/utils/aso-to-public/load-pull-data.util.ts
+import fs from "fs";
+import path from "path";
+function loadPullData(slug) {
+  const asoData = {};
+  const googlePlayPath = path.join(
+    process.cwd(),
+    ".aso",
+    "pullData",
+    "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(
+    process.cwd(),
+    ".aso",
+    "pullData",
+    "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/utils/aso-to-public/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-to-public.ts
+var toJsonSchema = zodToJsonSchema;
+var asoToPublicInputSchema = z.object({
+  slug: z.string().describe("Product slug")
+});
+var jsonSchema = toJsonSchema(asoToPublicInputSchema, {
+  name: "AsoToPublicInput",
+  target: "openApi3",
+  $refStrategy: "none"
+});
+var inputSchema = jsonSchema.definitions?.AsoToPublicInput || jsonSchema;
+var asoToPublicTool = {
+  name: "aso-to-public",
+  description: `Converts ASO data from .aso/pullData to public/products/[slug]/ structure.
+
+**IMPORTANT:** The 'slug' parameter is REQUIRED. If the user does not provide a slug, you MUST ask them to provide it. This tool processes only ONE product at a time.
+
+This tool:
+1. Loads ASO data from .aso/pullData/products/[slug]/store/
+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 .aso/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 = {};
+        screenshotPaths.googlePlay = `.aso/pullData/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 = {};
+        screenshotPaths.appStore = `.aso/pullData/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}`);
+  }
+  let responseText = `Converting ASO data from .aso/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 .aso/pullData/products/${slug}/store/ to public/products/${slug}/screenshots/
+`;
+  return {
+    content: [
+      {
+        type: "text",
+        text: responseText
+      }
+    ]
+  };
+}
+
+// src/tools/public-to-aso.ts
+import { z as z2 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema2 } from "zod-to-json-schema";
+import path4 from "path";
+
+// src/tools/utils/public-to-aso/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/utils/public-to-aso/save-raw-aso-data.util.ts
+function saveRawAsoData(slug, asoData, options) {
+  const rootDir = options?.rootDir ?? ".aso/pushData";
+  saveAsoToAsoDir(slug, asoData, { rootDir });
+  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/utils/public-to-aso/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/utils/public-to-aso/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/utils/public-to-aso/copy-local-asset-to-aso-dir.util.ts
+import fs3 from "fs";
+import path3 from "path";
+function copyLocalAssetToAsoDir(assetPath, outputPath) {
+  const trimmedPath = assetPath.replace(/^\.\//, "").replace(/^public\//, "").replace(/^\/+/, "");
+  const sourcePath = path3.join(process.cwd(), "public", 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/public-to-aso.ts
+var FIELD_LIMITS_DOC_PATH = "docs/aso/ASO_FIELD_LIMITS.md";
+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",
+  target: "openApi3",
+  $refStrategy: "none"
+});
+var inputSchema2 = jsonSchema2.definitions?.PublicToAsoInput || jsonSchema2;
+async function downloadScreenshotsToAsoDir(slug, asoData, options) {
+  const rootDir = options?.rootDir ?? ".aso/pushData";
+  const productStoreRoot = path4.join(
+    process.cwd(),
+    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
+      );
+      if (localeData.screenshots?.phone?.length > 0) {
+        for (let i = 0; i < localeData.screenshots.phone.length; i++) {
+          const url = localeData.screenshots.phone[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 .aso/pushData format.
+
+**IMPORTANT:** The 'slug' parameter is REQUIRED. If the user does not provide a slug, you MUST ask them to provide it. This tool processes only ONE product at a time.
+
+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/
+4. Copies/downloads screenshots to .aso/pushData/products/[slug]/store/screenshots/
+
+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);
+  if (!configData.googlePlay && !configData.appStore) {
+    throw new Error(`No ASO data found in config.json + locales/ for ${slug}`);
+  }
+  const storeData = prepareAsoDataForPush(slug, configData);
+  if (dryRun) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Preview mode - Data that would be saved to .aso/pushData:
+
+${JSON.stringify(
+            storeData,
+            null,
+            2
+          )}`
+        }
+      ]
+    };
+  }
+  const pushDataRoot = ".aso/pushData";
+  saveRawAsoData(slug, storeData, { rootDir: pushDataRoot });
+  await downloadScreenshotsToAsoDir(slug, configData, {
+    rootDir: pushDataRoot
+  });
+  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} .aso/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}`;
+  return {
+    content: [
+      {
+        type: "text",
+        text: responseText
+      }
+    ]
+  };
+}
+
+// src/tools/improve-public.ts
+import { z as z3 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema3 } from "zod-to-json-schema";
+
+// src/tools/utils/improve-public/load-product-locales.util.ts
+import fs4 from "fs";
+import path5 from "path";
+function loadProductLocales(slug) {
+  const productDir = path5.join(process.cwd(), "public", "products", slug);
+  const configPath = path5.join(productDir, "config.json");
+  const localesDir = path5.join(productDir, "locales");
+  let config = null;
+  if (fs4.existsSync(configPath)) {
+    const raw = fs4.readFileSync(configPath, "utf-8");
+    config = JSON.parse(raw);
+  }
+  if (!fs4.existsSync(localesDir)) {
+    throw new Error(`No locales directory found for ${slug}`);
+  }
+  const locales = {};
+  const localeFiles = fs4.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 = fs4.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/utils/improve-public/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/utils/improve-public/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/utils/improve-public/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/utils/improve-public/generate-aso-prompt.util.ts
+var FIELD_LIMITS_DOC_PATH2 = "docs/aso/ASO_FIELD_LIMITS.md";
+function generatePrimaryOptimizationPrompt(args) {
+  const { slug, category, primaryLocale, localeSections } = 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}) with keyword research + full ASO field optimization.
+
+`;
+  prompt += `## Step 1: Keyword Research (${primaryLocale})
+
+`;
+  prompt += `**Strategies** (apply all 5):
+`;
+  prompt += `1. **App Store**: Search top apps in category \u2192 extract keywords from titles/descriptions
+`;
+  prompt += `2. **Description-Based**: Use current shortDescription \u2192 find related ASO keywords
+`;
+  prompt += `3. **Feature-Based**: Identify 2-3 core features \u2192 search feature-specific keywords
+`;
+  prompt += `4. **User Intent**: Research user search patterns for the app's use case
+`;
+  prompt += `5. **Competitor**: Analyze 3+ successful apps \u2192 find common keyword patterns
+
+`;
+  prompt += `**Output**: 10 high-performing keywords
+
+`;
+  prompt += `## Step 2: Optimize All Fields (${primaryLocale})
+
+`;
+  prompt += `Apply the 10 keywords to ALL fields:
+`;
+  prompt += `- \`aso.title\` (\u226430): **"App Name: Primary Keyword"** format (app name in English, keyword in target language, keyword starts with uppercase after the colon)
+`;
+  prompt += `- \`aso.subtitle\` (\u226430): Complementary keywords
+`;
+  prompt += `- \`aso.shortDescription\` (\u226480): Primary keywords (no emojis/CAPS)
+`;
+  prompt += `- \`aso.keywords\` (\u2264100): Comma-separated 10 keywords
+`;
+  prompt += `- \`aso.template.intro\` (\u2264300): Keyword-rich, use full length
+`;
+  prompt += `- \`aso.template.outro\` (\u2264200): Natural keyword integration
+`;
+  prompt += `- \`landing.hero.title\`: Primary keywords
+`;
+  prompt += `- \`landing.hero.description\`: Keywords if present
+`;
+  prompt += `- \`landing.screenshots.images[].title\`: Keywords in screenshot titles
+`;
+  prompt += `- \`landing.screenshots.images[].description\`: Keywords in screenshot descriptions
+`;
+  prompt += `- \`landing.features.items[].title\`: Keywords in feature titles
+`;
+  prompt += `- \`landing.features.items[].body\`: Keywords in feature descriptions
+`;
+  prompt += `- \`landing.reviews.title\`: Keywords if applicable
+`;
+  prompt += `- \`landing.reviews.description\`: Keywords if applicable
+`;
+  prompt += `- \`landing.cta.headline\`: Keywords if applicable
+`;
+  prompt += `- \`landing.cta.description\`: Keywords if applicable
+
+`;
+  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, with all screenshots, features, reviews, and cta sections properly translated and keyword-optimized.
+
+`;
+  prompt += `## Step 3: Validate
+
+`;
+  prompt += `Check all limits: title \u226430, subtitle \u226430, shortDescription \u226480, keywords \u2264100, intro \u2264300, outro \u2264200
+
+`;
+  prompt += `## Current Data
+
+`;
+  prompt += `${localeSections.find((s) => s.includes(`[${primaryLocale}]`)) || localeSections[0]}
+
+`;
+  prompt += `## Output Format
+
+`;
+  prompt += `**1. Keyword Research**
+`;
+  prompt += `   - Query: "[query]" \u2192 Found: [apps] \u2192 Keywords: [list]
+`;
+  prompt += `   - Final 10 keywords: [list] with rationale
+
+`;
+  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
+`;
+  prompt += `   - intro: X/300 \u2713/\u2717
+`;
+  prompt += `   - outro: X/200 \u2713/\u2717
+`;
+  prompt += `   - Density: X% (2.5-3%) \u2713/\u2717
+
+`;
+  prompt += `**Reference**: ${FIELD_LIMITS_DOC_PATH2}
+`;
+  return prompt;
+}
+function generateKeywordLocalizationPrompt(args) {
+  const {
+    slug,
+    primaryLocale,
+    targetLocales,
+    localeSections,
+    optimizedPrimary,
+    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. Research 10 language-specific keywords
+`;
+  prompt += `2. Replace keywords in translated content (preserve structure/tone/context)
+`;
+  prompt += `3. Validate character limits
+`;
+  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}
+\`\`\`
+
+`;
+  prompt += `## Keyword Research (Per Locale)
+
+`;
+  prompt += `For EACH locale, perform lightweight keyword research:
+`;
+  prompt += `1. **App Store Search**: "[core feature] [lang] \uC571/app" \u2192 top 5 apps
+`;
+  prompt += `2. **Competitor Keywords**: Extract keywords from successful apps in that language
+`;
+  prompt += `3. **Search Trends**: Check what users actually search in that language
+
+`;
+  prompt += `**Output**: 10 keywords per locale
+
+`;
+  prompt += `## Keyword Replacement Strategy
+
+`;
+  prompt += `For EACH locale:
+`;
+  prompt += `1. Take the TRANSLATED content (below)
+`;
+  prompt += `2. Replace \`aso.keywords\` array with new 10 keywords
+`;
+  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 += `4. Swap keywords in sentences while keeping:
+`;
+  prompt += `   - Original sentence structure
+`;
+  prompt += `   - Tone and messaging
+`;
+  prompt += `   - Context and flow
+`;
+  prompt += `   - Character limits
+
+`;
+  prompt += `4. **CRITICAL**: Update ALL \`landing\` sections:
+`;
+  prompt += `   - \`landing.hero.title\` and \`landing.hero.description\`: Include keywords naturally
+`;
+  prompt += `   - \`landing.screenshots.images[].title\`: Incorporate keywords in all screenshot titles
+`;
+  prompt += `   - \`landing.screenshots.images[].description\`: Include keywords in all screenshot descriptions
+`;
+  prompt += `   - \`landing.features.items[].title\`: Add keywords to feature titles where natural
+`;
+  prompt += `   - \`landing.features.items[].body\`: Weave keywords into feature descriptions
+`;
+  prompt += `   - \`landing.reviews.title\` and \`landing.reviews.description\`: Include keywords if applicable
+`;
+  prompt += `   - \`landing.cta.headline\` and \`landing.cta.description\`: Include keywords if applicable
+`;
+  prompt += `   - Maintain original context and meaning
+`;
+  prompt += `   - Use language-specific terms that users actually search for
+`;
+  prompt += `   - **DO NOT leave any landing fields in English** - all must be translated
+
+`;
+  prompt += `**Example**:
+`;
+  prompt += `- Original: "Track aurora with real-time forecasts"
+`;
+  prompt += `- Korean keywords: \uC624\uB85C\uB77C, \uC608\uBCF4, \uC2E4\uC2DC\uAC04
+`;
+  prompt += `- Result: "\uC2E4\uC2DC\uAC04 \uC608\uBCF4\uB85C \uC624\uB85C\uB77C \uCD94\uC801"
+`;
+  prompt += `  (structure changed for Korean, but context preserved)
+
+`;
+  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. Research 10 keywords for locale
+`;
+  prompt += `2. Replace keywords in ALL fields:
+`;
+  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 += `   - \`landing.cta.headline\` and \`landing.cta.description\`
+`;
+  prompt += `3. **CRITICAL**: Ensure ALL landing fields are translated (not English)
+`;
+  prompt += `4. Validate limits
+`;
+  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 += `## Output Format (Per Locale)
+
+`;
+  prompt += `For EACH locale, provide:
+
+`;
+  prompt += `### Locale [locale-code]:
+
+`;
+  prompt += `**1. Keyword Research**
+`;
+  prompt += `   - Query: "[query]" \u2192 Keywords: [list]
+`;
+  prompt += `   - Final 10: [list] with rationale
+
+`;
+  prompt += `**2. Updated JSON** (complete locale structure with keyword replacements)
+`;
+  prompt += `   - MUST include complete \`aso\` object
+`;
+  prompt += `   - MUST include complete \`landing\` object with ALL sections:
+`;
+  prompt += `     * hero (title, description, titleHighlight)
+`;
+  prompt += `     * screenshots.images[] (all items with translated title and description)
+`;
+  prompt += `     * features.items[] (all items with translated title and body)
+`;
+  prompt += `     * reviews (title, description, icons, rating, testimonials)
+`;
+  prompt += `     * cta (headline, icons, rating, description)
+`;
+  prompt += `   - **NO English text in landing sections** - everything must be translated
+
+`;
+  prompt += `**3. Validation**
+`;
+  prompt += `   - All fields within limits \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(
+    ", "
+  )}
+`;
+  return prompt;
+}
+
+// src/tools/improve-public.ts
+var FIELD_LIMITS_DOC_PATH3 = "docs/aso/ASO_FIELD_LIMITS.md";
+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",
+  target: "openApi3",
+  $refStrategy: "none"
+});
+var inputSchema3 = jsonSchema3.definitions?.ImprovePublicInput || jsonSchema3;
+var improvePublicTool = {
+  name: "improve-public",
+  description: `Optimizes locale JSON in public/products/[slug]/locales for ASO.
+
+**IMPORTANT:** The 'slug' parameter is REQUIRED. If the user does not provide a slug, you MUST ask them to provide it. This tool processes only ONE product at a time.
+
+**CRITICAL: Only processes existing locale files. Does NOT create new locale files.**
+- Only improves locales that already exist in public/products/[slug]/locales/
+- If a locale file doesn't exist, it will be skipped (not created)
+- Always work with existing files only
+
+This tool follows a 2-stage workflow:
+
+**Stage 1: Primary Locale Optimization** (${FIELD_LIMITS_DOC_PATH3})
+1. Load product config + locales (primary: en-US default)
+2. Keyword research for PRIMARY locale only (web search for 10 keywords)
+3. Optimize ALL ASO fields in primary locale with keywords
+4. Validate character limits (title \u226430, subtitle \u226430, shortDescription \u226480, keywords \u2264100, intro \u2264300, outro \u2264200)
+
+**Stage 2: Keyword Localization** (Batch Processing)
+1. Translate optimized primary \u2192 target locales in batches (preserve structure/tone/context)
+2. For EACH locale in batch: lightweight keyword research (10 language-specific keywords)
+3. Replace keywords in translated content (swap keywords only, keep context)
+4. Validate character limits per locale
+5. Save each batch to files before proceeding to next batch
+6. **Only processes locales that already exist - does NOT create new files**
+
+**Batch Processing:**
+- Languages are processed in batches (default: 5 locales per batch)
+- Each batch is translated, optimized, and saved before moving to the next
+- Use \`batchIndex\` to process a specific batch (0-based)
+- If \`batchIndex\` is not provided, process all batches sequentially
+- **Only existing locale files are processed - missing locales are skipped**
+
+This approach ensures:
+- Efficient token usage (full optimization only once)
+- Consistent messaging across all languages
+- Language-specific keyword optimization for each market
+- Prevents content truncation by processing in manageable batches
+- **No new files are created - only existing locales are improved**
+
+Optionally target a single locale; the primary locale is always included for reference.`,
+  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 baseArgs = {
+    slug,
+    category,
+    primaryLocale,
+    targetLocales,
+    localeSections
+  };
+  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,
+        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/init-project.ts
+import fs5 from "fs";
+import path6 from "path";
+import { z as z4 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema4 } from "zod-to-json-schema";
+var listSlugDirs = (dir) => {
+  if (!fs5.existsSync(dir)) return [];
+  return fs5.readdirSync(dir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+};
+var initProjectInputSchema = z4.object({
+  slug: z4.string().trim().optional().describe(
+    "Optional product slug to focus on. Defaults to all slugs in .aso/pullData/products/"
+  )
+});
+var jsonSchema4 = zodToJsonSchema4(initProjectInputSchema, {
+  name: "InitProjectInput",
+  target: "openApi3",
+  $refStrategy: "none"
+});
+var inputSchema4 = jsonSchema4.definitions?.InitProjectInput || jsonSchema4;
+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
+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: inputSchema4
+};
+async function handleInitProject(input) {
+  const pullDataDir = path6.join(process.cwd(), ".aso", "pullData", "products");
+  const publicDir = path6.join(process.cwd(), "public", "products");
+  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 .aso/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/index.ts
+var tools = [
+  {
+    name: asoToPublicTool.name,
+    description: asoToPublicTool.description,
+    inputSchema: asoToPublicTool.inputSchema,
+    zodSchema: asoToPublicInputSchema,
+    handler: handleAsoToPublic,
+    category: "ASO Data Conversion"
+  },
+  {
+    name: publicToAsoTool.name,
+    description: publicToAsoTool.description,
+    inputSchema: publicToAsoTool.inputSchema,
+    zodSchema: publicToAsoInputSchema,
+    handler: handlePublicToAso,
+    category: "ASO Data Conversion"
+  },
+  {
+    name: improvePublicTool.name,
+    description: improvePublicTool.description,
+    inputSchema: improvePublicTool.inputSchema,
+    zodSchema: improvePublicInputSchema,
+    handler: handleImprovePublic,
+    category: "ASO Optimization"
+  },
+  {
+    name: initProjectTool.name,
+    description: initProjectTool.description,
+    inputSchema: initProjectTool.inputSchema,
+    zodSchema: initProjectInputSchema,
+    handler: handleInitProject,
+    category: "Setup"
+  }
+];
+function getToolDefinitions() {
+  return [
+    asoToPublicTool,
+    publicToAsoTool,
+    improvePublicTool,
+    initProjectTool
+  ];
+}
+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);
+});