pabal-web-mcp 1.2.4 → 1.3.0

package/README.md

@@ -2,142 +2,58 @@
 
 MCP (Model Context Protocol) server for bidirectional conversion between ASO (App Store Optimization) and web SEO data.
 
-This library enables seamless reuse of ASO data for web SEO purposes, allowing you to convert ASO metadata directly into web SEO content and vice versa.
+This library enables seamless reuse of ASO data for web SEO purposes, allowing you to convert ASO metadata directly into web SEO content and vice versa. **Build your own synced website** based on ASO data from App Store Connect and Google Play Console, keeping your app store listings and web presence perfectly synchronized.
+
+> 💡 **Example**: Check out [labs.quartz.best](https://labs.quartz.best/) to see a live website built with this library, where app store data is automatically synced to create a beautiful, SEO-optimized web presence.
 
 [![한국어 docs](https://img.shields.io/badge/docs-Korean-green)](./i18n/README.ko.md)
 
-## 🛠️ MCP Client Installation
+## 🛠️ Installation
 
 ### Requirements
 
 - Node.js >= 18
-- MCP client: Cursor, Claude Code, VS Code, Windsurf, etc.
-
-> [!TIP]
-> If you repeatedly do ASO/store tasks, add a client rule like "always use pabal-web-mcp" so the MCP server auto-invokes without typing it every time.
-
-<details>
-<summary><b>Install in Cursor</b></summary>
-
-Add to `~/.cursor/mcp.json` (global) or project `.cursor/mcp.json`:
-
-```json
-{
-  "mcpServers": {
-    "pabal-web-mcp": {
-      "command": "npx",
-      "args": ["-y", "pabal-web-mcp"]
-    }
-  }
-}
-```
-
-Or if installed globally:
-
-```json
-{
-  "mcpServers": {
-    "pabal-web-mcp": {
-      "command": "pabal-web-mcp"
-    }
-  }
-}
-```
-
-</details>
-
-<details>
-<summary><b>Install in VS Code</b></summary>
-
-Example `settings.json` MCP section:
-
-```json
-"mcp": {
-  "servers": {
-    "pabal-web-mcp": {
-      "type": "stdio",
-      "command": "npx",
-      "args": ["-y", "pabal-web-mcp"]
-    }
-  }
-}
-```
-
-Or if installed globally:
-
-```json
-"mcp": {
-  "servers": {
-    "pabal-web-mcp": {
-      "type": "stdio",
-      "command": "pabal-web-mcp"
-    }
-  }
-}
-```
-
-</details>
-
-<details>
-<summary><b>Install in Claude Code</b></summary>
+- [pabal-mcp](https://github.com/quartz-labs-dev/pabal-mcp) must be installed and configured
 
-> [!TIP]
-> See the [official Claude Code MCP documentation](https://code.claude.com/docs/en/mcp#setting-up-enterprise-mcp-configuration) for detailed configuration options.
+### Install as Library
 
-Add to Claude Code MCP settings (JSON format):
+Install this library in your website project:
 
-```json
-{
-  "mcpServers": {
-    "pabal-web-mcp": {
-      "command": "npx",
-      "args": ["-y", "pabal-web-mcp"]
-    }
-  }
-}
+```bash
+npm install pabal-web-mcp
+# or
+yarn add pabal-web-mcp
+# or
+pnpm add pabal-web-mcp
 ```
 
-Or if installed globally (`npm install -g pabal-web-mcp`):
+## 🔐 Configure Credentials
 
-```json
-{
-  "mcpServers": {
-    "pabal-web-mcp": {
-      "command": "pabal-web-mcp"
-    }
-  }
-}
-```
+pabal-web-mcp uses the configuration file from `pabal-mcp`. For detailed credential setup instructions (App Store Connect API keys, Google Play service accounts, etc.), please refer to the [pabal-mcp README](https://github.com/quartz-labs-dev/pabal-mcp?tab=readme-ov-file#-configure-credentials).
 
-</details>
+### ⚠️ Important: Set dataDir Path
 
-<details>
-<summary><b>Install in Windsurf</b></summary>
+**You must set `dataDir` in `~/.config/pabal-mcp/config.json` to the absolute path where your `pabal-web` project is stored on your local machine.**
 
 ```json
 {
-  "mcpServers": {
-    "pabal-web-mcp": {
-      "command": "npx",
-      "args": ["-y", "pabal-web-mcp"]
-    }
+  "dataDir": "/ABSOLUTE/PATH/TO/pabal-web",
+  "appStore": {
+    "issuerId": "xxxx",
+    "keyId": "xxxx",
+    "privateKeyPath": "./app-store-key.p8"
+  },
+  "googlePlay": {
+    "serviceAccountKeyPath": "./google-play-service-account.json"
   }
 }
 ```
 
-Or if installed globally:
+Examples:
 
-```json
-{
-  "mcpServers": {
-    "pabal-web-mcp": {
-      "command": "pabal-web-mcp"
-    }
-  }
-}
-```
-
-</details>
+- macOS: `"/Users/username/projects/pabal-web"`
+- Linux: `"/home/username/projects/pabal-web"`
+- Windows: `"C:\\Users\\username\\projects\\pabal-web"`
 
 ## MCP Server
 
@@ -145,87 +61,34 @@ This package includes an MCP server for managing ASO data through Claude or othe
 
 ### Available Tools
 
-| Tool             | Description                                        |
-| ---------------- | -------------------------------------------------- |
-| `aso-to-public`  | Convert ASO data to public config format           |
-| `public-to-aso`  | Convert public config to ASO data format           |
-| `improve-public` | Improve product locale content with AI suggestions |
-| `init-project`   | Initialize a new product project structure         |
-
-## Usage
-
-### Importing Types
-
-```typescript
-import type {
-  // ASO Types
-  AsoData,
-  AppStoreAsoData,
-  GooglePlayAsoData,
-
-  // Product Types
-  ProductConfig,
-  ProductLocale,
-  LandingPage,
-  LandingHero,
-  LandingScreenshots,
-  LandingFeatures,
-  LandingReviews,
-  LandingCta,
-} from "pabal-web-mcp";
-```
-
-### Importing Utilities
-
-```typescript
-import {
-  // ASO Converter
-  loadAsoFromConfig,
-
-  // Locale Constants
-  DEFAULT_LOCALE,
-  UNIFIED_LOCALES,
-
-  // Locale Converters
-  unifiedToAppStore,
-  unifiedToGooglePlay,
-  appStoreToUnified,
-  googlePlayToUnified,
-} from "pabal-web-mcp";
-```
-
-### Example: Loading ASO Data
-
-```typescript
-import { loadAsoFromConfig } from "pabal-web-mcp";
-
-const asoData = loadAsoFromConfig("my-app");
-console.log(asoData.appStore?.name);
-console.log(asoData.googlePlay?.title);
-```
-
-## Types Reference
-
-### ASO Types
-
-- `AsoData` - Combined ASO data for both stores
-- `AppStoreAsoData` - App Store specific ASO data
-- `GooglePlayAsoData` - Google Play specific ASO data
-- `AppStoreMultilingualAsoData` - Multilingual App Store data
-- `GooglePlayMultilingualAsoData` - Multilingual Google Play data
-
-### Product Types
-
-- `ProductConfig` - Product configuration
-- `ProductLocale` - Localized product content
-- `LandingPage` - Landing page structure
-- `AppPageData` - Complete app page data
-
-### Locale Types
-
-- `UnifiedLocale` - Unified locale code (e.g., "en-US", "ko-KR")
-
-## Supported Locales
+| Tool               | Description                                              |
+| ------------------ | -------------------------------------------------------- |
+| `aso-to-public`    | Convert ASO data to public config format                 |
+| `public-to-aso`    | Convert public config to ASO data format                 |
+| `keyword-research` | Plan/persist ASO keyword research (.aso/keywordResearch) |
+| `improve-public`   | Improve product locale content with AI suggestions       |
+| `init-project`     | Initialize a new product project structure               |
+| `create-blog-html` | Generate static HTML blog posts with BLOG_META headers   |
+
+### Using external keyword MCP ([appreply-co/mcp-appstore](https://github.com/appreply-co/mcp-appstore))
+
+1. Install deps in the existing clone: `cd external-tools/mcp-appstore && npm install`
+2. Run server: `node server.js` (same cwd; `npm start` also works). If your MCP client allows, let the LLM start this process before keyword research and stop it after; otherwise start/stop it manually.
+3. Register in your MCP client (example):
+   ```json
+   {
+     "mcpServers": {
+       "mcp-appstore": {
+         "command": "node",
+         "args": ["/ABSOLUTE/PATH/TO/pabal-web-mcp/external-tools/mcp-appstore/server.js"],
+         "cwd": "/ABSOLUTE/PATH/TO/pabal-web-mcp/external-tools/mcp-appstore"
+       }
+     }
+   }
+   ```
+4. Use it with `keyword-research` (saves to `.aso/keywordResearch/...`) before `improve-public` to supply keyword data.
+
+### Supported Locales
 
 Supports all languages supported by each store.
 

package/dist/bin/mcp-server.js

@@ -3,13 +3,14 @@ import {
   DEFAULT_APP_SLUG
 } from "../chunk-DLCIXAUB.js";
 import {
+  getKeywordResearchDir,
   getProductsDir,
   getPublicDir,
   getPullDataDir,
   getPushDataDir,
   loadAsoFromConfig,
   saveAsoToAsoDir
-} from "../chunk-FXCHLO7O.js";
+} from "../chunk-W62HB2ZL.js";
 import {
   DEFAULT_LOCALE,
   appStoreToUnified,
@@ -1194,7 +1195,14 @@ ${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;
+  const {
+    slug,
+    category,
+    primaryLocale,
+    localeSections,
+    keywordResearchByLocale,
+    keywordResearchDirByLocale
+  } = args;
   let prompt = `# ASO Optimization - Stage 1: Primary Locale
 
 `;
@@ -1204,32 +1212,33 @@ function generatePrimaryOptimizationPrompt(args) {
   prompt += `## Task
 
 `;
-  prompt += `Optimize the PRIMARY locale (${primaryLocale}) with keyword research + full ASO field optimization.
+  prompt += `Optimize the PRIMARY locale (${primaryLocale}) using **saved 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
+  const researchSections = keywordResearchByLocale[primaryLocale] || [];
+  const researchDir = keywordResearchDirByLocale[primaryLocale];
+  if (researchSections.length > 0) {
+    prompt += `Use the **saved keyword research below**. Do NOT invent new keywords. Choose the top 10 from the recommended set.
+
 `;
-  prompt += `5. **Competitor**: Analyze 3+ successful apps \u2192 find common keyword patterns
+    prompt += `Saved research:
+${researchSections.join("\n")}
 
 `;
-  prompt += `**Output**: 10 high-performing keywords
+  } 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 += `## Step 2: Optimize All Fields (${primaryLocale})
 
 `;
-  prompt += `Apply the 10 keywords to ALL fields:
+  prompt += `Apply the selected 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)
 `;
@@ -1284,11 +1293,11 @@ function generatePrimaryOptimizationPrompt(args) {
   prompt += `## Output Format
 
 `;
-  prompt += `**1. Keyword Research**
+  prompt += `**1. Keyword Research (from saved data)**
 `;
-  prompt += `   - Query: "[query]" \u2192 Found: [apps] \u2192 Keywords: [list]
+  prompt += `   - Cite file(s) used and list the selected top 10 keywords (no new research)
 `;
-  prompt += `   - Final 10 keywords: [list] with rationale
+  prompt += `   - Rationale: why these 10 were chosen from saved research
 
 `;
   prompt += `**2. Optimized JSON** (complete ${primaryLocale} locale structure)
@@ -1336,6 +1345,8 @@ function generateKeywordLocalizationPrompt(args) {
     targetLocales,
     localeSections,
     optimizedPrimary,
+    keywordResearchByLocale,
+    keywordResearchDirByLocale,
     batchLocales,
     batchIndex,
     totalBatches,
@@ -1379,7 +1390,7 @@ function generateKeywordLocalizationPrompt(args) {
 `;
   prompt += `For EACH target locale in this batch:
 `;
-  prompt += `1. Research 10 language-specific keywords
+  prompt += `1. Use SAVED keyword research (see per-locale data below). Do NOT invent keywords.
 `;
   prompt += `2. Replace keywords in translated content (preserve structure/tone/context)
 `;
@@ -1400,18 +1411,22 @@ ${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
+  nonPrimaryLocales.forEach((loc) => {
+    const researchSections = keywordResearchByLocale[loc] || [];
+    const researchDir = keywordResearchDirByLocale[loc];
+    if (researchSections.length > 0) {
+      prompt += `Locale ${loc}: use saved research below. Do NOT invent keywords.
+${researchSections.join(
+        "\n"
+      )}
 
 `;
-  prompt += `**Output**: 10 keywords per locale
+    } else {
+      prompt += `Locale ${loc}: no saved keyword research found at ${researchDir}. Stop and request running 'keyword-research' tool (slug='${slug}', locale='${loc}', platform/country as appropriate\u2014match the store locale), then rerun stage 2.
 
 `;
+    }
+  });
   prompt += `## Keyword Replacement Strategy
 
 `;
@@ -1492,7 +1507,7 @@ ${optimizedPrimary}
 `;
   prompt += `Process EACH locale in this batch sequentially:
 `;
-  prompt += `1. Research 10 keywords for locale
+  prompt += `1. Use saved keyword research (or pause if missing and request keyword-research run)
 `;
   prompt += `2. Replace keywords in ALL fields:
 `;
@@ -1548,11 +1563,11 @@ ${optimizedPrimary}
   prompt += `### Locale [locale-code]:
 
 `;
-  prompt += `**1. Keyword Research**
+  prompt += `**1. Keyword Research (saved)**
 `;
-  prompt += `   - Query: "[query]" \u2192 Keywords: [list]
+  prompt += `   - Cite file(s) used; list selected top 10 keywords (no new research)
 `;
-  prompt += `   - Final 10: [list] with rationale
+  prompt += `   - Rationale: why these were chosen from saved research
 
 `;
   prompt += `**2. Updated JSON** (complete locale structure with keyword replacements)
@@ -1596,6 +1611,92 @@ ${optimizedPrimary}
   return prompt;
 }
 
+// src/tools/utils/improve-public/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(String);
+  }
+  if (typeof recommended === "string") {
+    return [recommended];
+  }
+  return [];
+}
+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);
+  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 (meta.seedKeywords?.length) {
+    lines.push(`Seeds: ${meta.seedKeywords.join(", ")}`);
+  }
+  if (meta.competitorApps?.length) {
+    const competitors = meta.competitorApps.map((c) => `${c.platform || "?"}:${c.appId || "?"}`).join(", ");
+    lines.push(`Competitors: ${competitors}`);
+  }
+  if (recommended.length) {
+    lines.push(`Recommended keywords (${recommended.length}): ${recommended.join(", ")}`);
+  } else {
+    lines.push("Recommended keywords: (not provided)");
+  }
+  lines.push("----");
+  return lines.join("\n");
+}
+function loadKeywordResearchForLocale(slug, locale) {
+  const researchDir = path6.join(
+    getKeywordResearchDir(),
+    "products",
+    slug,
+    "locales",
+    locale
+  );
+  if (!fs6.existsSync(researchDir)) {
+    return { entries: [], sections: [], researchDir };
+  }
+  const files = fs6.readdirSync(researchDir).filter((file) => file.endsWith(".json"));
+  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 sections = entries.map(formatEntry);
+  return { entries, sections, researchDir };
+}
+
 // src/tools/improve-public.ts
 var FIELD_LIMITS_DOC_PATH3 = "docs/aso/ASO_FIELD_LIMITS.md";
 var toJsonSchema3 = zodToJsonSchema3;
@@ -1712,12 +1813,21 @@ async function handleImprovePublic(input) {
       })
     );
   }
+  const keywordResearchByLocale = {};
+  const keywordResearchDirByLocale = {};
+  for (const loc of targetLocales) {
+    const research = loadKeywordResearchForLocale(slug, loc);
+    keywordResearchByLocale[loc] = research.sections;
+    keywordResearchDirByLocale[loc] = research.researchDir;
+  }
   const baseArgs = {
     slug,
     category,
     primaryLocale,
     targetLocales,
-    localeSections
+    localeSections,
+    keywordResearchByLocale,
+    keywordResearchDirByLocale
   };
   if (stage === "1" || stage === "both") {
     const prompt = generatePrimaryOptimizationPrompt(baseArgs);
@@ -1763,6 +1873,8 @@ async function handleImprovePublic(input) {
         primaryLocale: baseArgs.primaryLocale,
         targetLocales: baseArgs.targetLocales,
         localeSections: baseArgs.localeSections,
+        keywordResearchByLocale: baseArgs.keywordResearchByLocale,
+        keywordResearchDirByLocale: baseArgs.keywordResearchDirByLocale,
         optimizedPrimary,
         batchLocales,
         batchIndex: currentBatchIndex,
@@ -1785,13 +1897,13 @@ async function handleImprovePublic(input) {
 }
 
 // src/tools/init-project.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 import { z as z4 } from "zod";
 import { zodToJsonSchema as zodToJsonSchema4 } from "zod-to-json-schema";
 var listSlugDirs = (dir) => {
-  if (!fs6.existsSync(dir)) return [];
-  return fs6.readdirSync(dir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+  if (!fs7.existsSync(dir)) return [];
+  return fs7.readdirSync(dir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
 };
 var initProjectInputSchema = z4.object({
   slug: z4.string().trim().optional().describe(
@@ -1816,7 +1928,7 @@ Steps:
   inputSchema: inputSchema4
 };
 async function handleInitProject(input) {
-  const pullDataDir = path6.join(getPullDataDir(), "products");
+  const pullDataDir = path7.join(getPullDataDir(), "products");
   const publicDir = getProductsDir();
   const pullDataSlugs = listSlugDirs(pullDataDir);
   const publicSlugs = listSlugDirs(publicDir);
@@ -1894,14 +2006,14 @@ async function handleInitProject(input) {
 }
 
 // src/tools/create-blog-html.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path9 from "path";
 import { z as z5 } from "zod";
 import { zodToJsonSchema as zodToJsonSchema5 } from "zod-to-json-schema";
 
 // src/utils/blog.util.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 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, "");
@@ -1989,13 +2101,13 @@ function resolveTargetLocales(input) {
   return fallback ? [fallback] : [];
 }
 function getBlogOutputPaths(options) {
-  const baseDir = path7.join(
+  const baseDir = path8.join(
     options.publicDir,
     BLOG_ROOT,
     options.appSlug,
     options.slug
   );
-  const filePath = path7.join(baseDir, `${options.locale}.html`);
+  const filePath = path8.join(baseDir, `${options.locale}.html`);
   const publicBasePath = toPublicBlogBase(options.appSlug, options.slug);
   return { baseDir, filePath, publicBasePath };
 }
@@ -2020,18 +2132,18 @@ function findExistingBlogPosts({
   publicDir,
   limit = 2
 }) {
-  const blogAppDir = path7.join(publicDir, BLOG_ROOT, appSlug);
-  if (!fs7.existsSync(blogAppDir)) {
+  const blogAppDir = path8.join(publicDir, BLOG_ROOT, appSlug);
+  if (!fs8.existsSync(blogAppDir)) {
     return [];
   }
   const posts = [];
-  const subdirs = fs7.readdirSync(blogAppDir, { withFileTypes: true });
+  const subdirs = fs8.readdirSync(blogAppDir, { withFileTypes: true });
   for (const subdir of subdirs) {
     if (!subdir.isDirectory()) continue;
-    const localeFile = path7.join(blogAppDir, subdir.name, `${locale}.html`);
-    if (!fs7.existsSync(localeFile)) continue;
+    const localeFile = path8.join(blogAppDir, subdir.name, `${locale}.html`);
+    if (!fs8.existsSync(localeFile)) continue;
     try {
-      const htmlContent = fs7.readFileSync(localeFile, "utf-8");
+      const htmlContent = fs8.readFileSync(localeFile, "utf-8");
       const { meta, body } = parseBlogHtml(htmlContent);
       if (meta && meta.locale === locale) {
         posts.push({
@@ -2174,7 +2286,7 @@ async function handleCreateBlogHtml(input) {
   }
   const output = {
     slug,
-    baseDir: path8.join(publicDir, "blogs", appSlug, slug),
+    baseDir: path9.join(publicDir, "blogs", appSlug, slug),
     files: [],
     coverImage: coverImage && coverImage.trim().length > 0 ? coverImage.trim() : `/products/${appSlug}/og-image.png`,
     metaByLocale: {}
@@ -2188,7 +2300,7 @@ async function handleCreateBlogHtml(input) {
     })
   );
   const existing = plannedFiles.filter(
-    ({ filePath }) => fs8.existsSync(filePath)
+    ({ filePath }) => fs9.existsSync(filePath)
   );
   if (existing.length > 0 && !overwrite) {
     const existingList = existing.map((f) => f.filePath).join("\n- ");
@@ -2197,7 +2309,7 @@ async function handleCreateBlogHtml(input) {
 - ${existingList}`
     );
   }
-  fs8.mkdirSync(output.baseDir, { recursive: true });
+  fs9.mkdirSync(output.baseDir, { recursive: true });
   for (const locale of targetLocales) {
     const { filePath } = getBlogOutputPaths({
       appSlug,
@@ -2223,7 +2335,7 @@ async function handleCreateBlogHtml(input) {
       meta,
       content
     });
-    fs8.writeFileSync(filePath, html, "utf-8");
+    fs9.writeFileSync(filePath, html, "utf-8");
     output.files.push({ locale, path: filePath });
   }
   const summaryLines = [
@@ -2259,6 +2371,243 @@ Writing style reference for ${locale}: Found ${posts.length} existing post(s) us
   };
 }
 
+// src/tools/keyword-research.ts
+import fs10 from "fs";
+import path10 from "path";
+import { z as z6 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema6 } from "zod-to-json-schema";
+var TOOL_NAME = "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."
+  )
+});
+var jsonSchema6 = zodToJsonSchema6(keywordResearchInputSchema, {
+  name: "KeywordResearchInput",
+  $refStrategy: "none"
+});
+var inputSchema6 = jsonSchema6.definitions?.KeywordResearchInput || jsonSchema6;
+var keywordResearchTool = {
+  name: TOOL_NAME,
+  description: `Prep + persist keyword research ahead of improve-public using mcp-appstore outputs.
+
+Run this before improve-public. It gives a concrete MCP-powered research plan and a storage path under .aso/keywordResearch/products/[slug]/locales/[locale]/. Optionally writes a template or saves raw JSON from mcp-appstore tools.`,
+  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: [
+        "Start mcp-appstore server (npm start in external-tools/mcp-appstore).",
+        "Discover competitors: search_app(term=seed keyword), get_similar_apps(appId=known competitor).",
+        "Collect candidates: suggest_keywords_by_seeds, suggest_keywords_by_category, suggest_keywords_by_similarity, suggest_keywords_by_competition.",
+        "Score shortlist: get_keyword_scores for 15\u201330 candidates per platform/country.",
+        "Context check: analyze_reviews on top apps for language/tone cues."
+      ],
+      note: "Run per platform/country. Save raw tool outputs plus curated top keywords."
+    },
+    data: {
+      raw: {
+        searchApp: [],
+        keywordSuggestions: {
+          bySeeds: [],
+          byCategory: [],
+          bySimilarity: [],
+          byCompetition: [],
+          bySearchHints: []
+        },
+        keywordScores: [],
+        reviewsAnalysis: []
+      },
+      summary: {
+        recommendedKeywords: [],
+        rationale: "",
+        nextActions: "Feed top 10\u201315 into improve-public Stage 1."
+      }
+    }
+  };
+}
+function saveJsonFile({
+  researchDir,
+  fileName,
+  payload
+}) {
+  fs10.mkdirSync(researchDir, { recursive: true });
+  const outputPath = path10.join(researchDir, fileName);
+  fs10.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
+  } = input;
+  const { config, locales } = loadProductLocales(slug);
+  const primaryLocale = resolvePrimaryLocale(config, locales);
+  const primaryLocaleData = locales[primaryLocale];
+  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 (platform === "ios") {
+    if (config?.appStoreAppId) {
+      autoCompetitors.push({ appId: String(config.appStoreAppId), platform });
+    } else if (config?.bundleId) {
+      autoCompetitors.push({ appId: config.bundleId, platform });
+    }
+  } else if (platform === "android" && config?.packageName) {
+    autoCompetitors.push({ appId: config.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 = path10.join(
+    getKeywordResearchDir(),
+    "products",
+    slug,
+    "locales",
+    locale
+  );
+  const defaultFileName = `keyword-research-${platform}-${resolvedCountry}.json`;
+  const fileName = filename || defaultFileName;
+  let outputPath = path10.join(researchDir, fileName);
+  let fileAction;
+  if (writeTemplate || researchData) {
+    const payload = researchData ? (() => {
+      try {
+        return JSON.parse(researchData);
+      } catch (err) {
+        throw new Error(
+          `Failed to parse researchData JSON: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    })() : 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}`);
+  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("How to run (uses mcp-appstore):");
+  lines.push(
+    `1) Start the local mcp-appstore server for this run: node server.js (cwd: /ABSOLUTE/PATH/TO/pabal-web-mcp/external-tools/mcp-appstore). LLM should start it before calling tools and stop it after, if the client supports process management; otherwise, start/stop manually.`
+  );
+  lines.push(
+    `2) Discover apps: search_app(term=seed, platform=${platform}, country=${country}); get_similar_apps(appId=known competitor).`
+  );
+  lines.push(
+    `3) Expand keywords: suggest_keywords_by_seeds, suggest_keywords_by_category, suggest_keywords_by_similarity, suggest_keywords_by_competition, suggest_keywords_by_search.`
+  );
+  lines.push(
+    `4) Score shortlist: get_keyword_scores for 15\u201330 candidates (note: scores are heuristic per README).`
+  );
+  lines.push(
+    `5) Context check: analyze_reviews on top apps to harvest native phrasing; keep snippets for improve-public.`
+  );
+  lines.push(
+    `6) Save all raw responses + your final top 10\u201315 keywords to: ${outputPath} (structure mirrors .aso/pullData/.aso/pushData under products/<slug>/locales/<locale>)`
+  );
+  if (fileAction) {
+    lines.push(`File: ${fileAction} at ${outputPath}`);
+  } else {
+    lines.push(
+      `Tip: set writeTemplate=true to create the JSON skeleton at ${outputPath}`
+    );
+  }
+  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/index.ts
 var tools = [
   {
@@ -2300,6 +2649,14 @@ var tools = [
     zodSchema: createBlogHtmlInputSchema,
     handler: handleCreateBlogHtml,
     category: "Content"
+  },
+  {
+    name: keywordResearchTool.name,
+    description: keywordResearchTool.description,
+    inputSchema: keywordResearchTool.inputSchema,
+    zodSchema: keywordResearchInputSchema,
+    handler: handleKeywordResearch,
+    category: "ASO Research"
   }
 ];
 function getToolDefinitions() {
@@ -2308,7 +2665,8 @@ function getToolDefinitions() {
     publicToAsoTool,
     improvePublicTool,
     initProjectTool,
-    createBlogHtmlTool
+    createBlogHtmlTool,
+    keywordResearchTool
   ];
 }
 function getToolHandler(name) {

package/dist/chunk-W62HB2ZL.js

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

package/dist/index.d.ts

@@ -40,9 +40,13 @@ declare function getPushDataDir(): string;
  * Get the public directory path (dataDir/public)
  */
 declare function getPublicDir(): string;
+/**
+ * Get the keywordResearch directory path (dataDir/.aso/keywordResearch)
+ */
+declare function getKeywordResearchDir(): string;
 /**
  * Get the products directory path (dataDir/public/products)
  */
 declare function getProductsDir(): string;
 
-export { AsoData, ProductConfig, getAsoDataDir, getProductsDir, getPublicDir, getPullDataDir, getPushDataDir, loadAsoFromConfig, saveAsoToAsoDir, saveAsoToConfig };
+export { AsoData, ProductConfig, getAsoDataDir, getKeywordResearchDir, getProductsDir, getPublicDir, getPullDataDir, getPushDataDir, loadAsoFromConfig, saveAsoToAsoDir, saveAsoToConfig };

package/dist/index.js

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

package/package.json

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