daiso 1.0.4 → 1.0.5

package/dist/services/megabox/location.js

@@ -0,0 +1,219 @@
+/**
+ * 메가박스 위치 해석 및 근처 지점 조회 보조 모듈
+ */
+import { fetchJson } from '../../utils/http.js';
+import { fetchMegaboxBookingList, fetchMegaboxTheaterInfo } from './client.js';
+const DEFAULT_LATITUDE = 37.5665;
+const DEFAULT_LONGITUDE = 126.978;
+const DEFAULT_AREA_CODE = '11';
+const DEFAULT_TIMEOUT_MS = 15000;
+const GEOCODE_CACHE_TTL_MS = 60 * 60 * 1000;
+const megaboxGeocodeCache = new Map();
+const MEGABOX_AREA_CODE_BY_REGION = [
+    ['서울특별시', '11'],
+    ['서울', '11'],
+    ['부산광역시', '26'],
+    ['부산', '26'],
+    ['대구광역시', '27'],
+    ['대구', '27'],
+    ['인천광역시', '28'],
+    ['인천', '28'],
+    ['광주광역시', '29'],
+    ['광주', '29'],
+    ['대전광역시', '30'],
+    ['대전', '30'],
+    ['울산광역시', '31'],
+    ['울산', '31'],
+    ['세종특별자치시', '36'],
+    ['세종', '36'],
+    ['경기도', '41'],
+    ['경기', '41'],
+    ['강원특별자치도', '42'],
+    ['강원도', '42'],
+    ['강원', '42'],
+    ['충청북도', '43'],
+    ['충북', '43'],
+    ['충청남도', '44'],
+    ['충남', '44'],
+    ['전북특별자치도', '45'],
+    ['전라북도', '45'],
+    ['전북', '45'],
+    ['전라남도', '46'],
+    ['전남', '46'],
+    ['경상북도', '47'],
+    ['경북', '47'],
+    ['경상남도', '48'],
+    ['경남', '48'],
+    ['제주특별자치도', '50'],
+    ['제주도', '50'],
+    ['제주', '50'],
+];
+function calculateDistanceKm(lat1, lng1, lat2, lng2) {
+    const toRad = (deg) => (deg * Math.PI) / 180;
+    const dLat = toRad(lat2 - lat1);
+    const dLng = toRad(lng2 - lng1);
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return 6371 * c;
+}
+function isValidCoordinate(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function resolveAreaCodeFromText(text) {
+    const normalized = text.replace(/\s+/g, '');
+    for (const [region, areaCode] of MEGABOX_AREA_CODE_BY_REGION) {
+        if (normalized.includes(region.replace(/\s+/g, ''))) {
+            return areaCode;
+        }
+    }
+    return null;
+}
+function resolveAreaCodeFromGeocodeResult(result) {
+    for (const component of result.address_components || []) {
+        const candidates = [component.long_name || '', component.short_name || ''];
+        for (const candidate of candidates) {
+            const areaCode = resolveAreaCodeFromText(candidate);
+            if (areaCode) {
+                return areaCode;
+            }
+        }
+    }
+    return resolveAreaCodeFromText(result.formatted_address || '');
+}
+async function geocodeMegaboxLocation(params, options = {}) {
+    const apiKey = (options.googleMapsApiKey || '').trim();
+    if (apiKey.length === 0) {
+        return null;
+    }
+    const hasCoordinates = isValidCoordinate(params.latitude) && isValidCoordinate(params.longitude);
+    const keyword = (params.keyword || '').trim();
+    if (!hasCoordinates && keyword.length === 0) {
+        return null;
+    }
+    const cacheKey = hasCoordinates ? `coords:${params.latitude},${params.longitude}` : `keyword:${keyword}`;
+    const cached = megaboxGeocodeCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.value;
+    }
+    const endpoint = new URL('https://maps.googleapis.com/maps/api/geocode/json');
+    if (hasCoordinates) {
+        endpoint.searchParams.set('latlng', `${params.latitude},${params.longitude}`);
+    }
+    else {
+        endpoint.searchParams.set('address', keyword);
+    }
+    endpoint.searchParams.set('key', apiKey);
+    const body = await fetchJson(endpoint.toString(), {
+        method: 'GET',
+        timeout: options.timeout || DEFAULT_TIMEOUT_MS,
+        headers: {
+            Accept: 'application/json',
+        },
+    });
+    if (body.status !== 'OK') {
+        megaboxGeocodeCache.set(cacheKey, {
+            expiresAt: Date.now() + GEOCODE_CACHE_TTL_MS,
+            value: null,
+        });
+        return null;
+    }
+    const firstResult = body.results?.[0];
+    const latitude = firstResult?.geometry?.location?.lat;
+    const longitude = firstResult?.geometry?.location?.lng;
+    const areaCode = firstResult ? resolveAreaCodeFromGeocodeResult(firstResult) : null;
+    const value = typeof latitude === 'number' && typeof longitude === 'number'
+        ? { latitude, longitude, areaCode }
+        : null;
+    megaboxGeocodeCache.set(cacheKey, {
+        expiresAt: Date.now() + GEOCODE_CACHE_TTL_MS,
+        value,
+    });
+    return value;
+}
+export async function resolveMegaboxLocation(params, options = {}) {
+    const explicitAreaCode = (params.areaCode || '').trim();
+    const keyword = (params.keyword || '').trim();
+    const hasCoordinates = isValidCoordinate(params.latitude) && isValidCoordinate(params.longitude);
+    let latitude = hasCoordinates ? params.latitude : DEFAULT_LATITUDE;
+    let longitude = hasCoordinates ? params.longitude : DEFAULT_LONGITUDE;
+    let areaCode = explicitAreaCode || '';
+    let geocodeUsed = false;
+    if (!explicitAreaCode || !hasCoordinates) {
+        const geocoded = await geocodeMegaboxLocation(params, options);
+        if (geocoded) {
+            if (!hasCoordinates) {
+                latitude = geocoded.latitude;
+                longitude = geocoded.longitude;
+            }
+            if (!explicitAreaCode && geocoded.areaCode) {
+                areaCode = geocoded.areaCode;
+            }
+            geocodeUsed = true;
+        }
+    }
+    return {
+        keyword: keyword.length > 0 ? keyword : null,
+        latitude,
+        longitude,
+        areaCode: areaCode || DEFAULT_AREA_CODE,
+        geocodeUsed,
+    };
+}
+export async function fetchMegaboxNearbyTheaters(params, options = {}) {
+    const timeout = params.timeout || DEFAULT_TIMEOUT_MS;
+    const limit = Math.max(1, params.limit || 10);
+    const resolved = await resolveMegaboxLocation(params, options);
+    const { theaters } = await fetchMegaboxBookingList({
+        playDate: params.playDate,
+        areaCode: resolved.areaCode,
+        timeout,
+    });
+    const infoResults = await Promise.allSettled(theaters.map((theater) => fetchMegaboxTheaterInfo(theater.theaterId, timeout)));
+    const merged = theaters
+        .map((theater, index) => {
+        const infoResult = infoResults[index];
+        if (infoResult.status !== 'fulfilled') {
+            return null;
+        }
+        const info = infoResult.value;
+        if (info.latitude === null || info.longitude === null) {
+            return null;
+        }
+        return {
+            theaterId: theater.theaterId,
+            theaterName: theater.theaterName,
+            address: info.address,
+            latitude: info.latitude,
+            longitude: info.longitude,
+            distanceKm: Number(calculateDistanceKm(resolved.latitude, resolved.longitude, info.latitude, info.longitude).toFixed(2)),
+        };
+    })
+        .filter((theater) => theater !== null)
+        .sort((left, right) => left.distanceKm - right.distanceKm)
+        .slice(0, limit);
+    return {
+        ...resolved,
+        playDate: params.playDate,
+        count: merged.length,
+        theaters: merged,
+    };
+}
+export async function resolveMegaboxNearestTheater(params, options = {}) {
+    const location = await resolveMegaboxLocation(params, options);
+    const nearby = await fetchMegaboxNearbyTheaters({
+        ...params,
+        playDate: params.playDate,
+        limit: 1,
+        areaCode: location.areaCode,
+        latitude: location.latitude,
+        longitude: location.longitude,
+    }, options);
+    return {
+        theater: nearby.theaters[0] || null,
+        location,
+    };
+}
+export function __testOnlyClearMegaboxLocationCaches() {
+    megaboxGeocodeCache.clear();
+}

package/dist/services/megabox/tools/findNearbyTheaters.js

@@ -2,54 +2,22 @@
  * 메가박스 주변 지점 탐색 도구
  */
 import * as z from 'zod';
-import { fetchMegaboxBookingList, fetchMegaboxTheaterInfo, toYyyymmdd } from '../client.js';
-function calculateDistanceKm(lat1, lng1, lat2, lng2) {
-    const toRad = (deg) => (deg * Math.PI) / 180;
-    const dLat = toRad(lat2 - lat1);
-    const dLng = toRad(lng2 - lng1);
-    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-        Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
-    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-    return 6371 * c;
-}
+import { toYyyymmdd } from '../client.js';
+import { fetchMegaboxNearbyTheaters } from '../location.js';
 async function findNearbyTheaters(args) {
-    const { latitude = 37.5665, longitude = 126.978, playDate = toYyyymmdd(), areaCode = '11', limit = 10, timeoutMs = 15000, } = args;
-    const { theaters } = await fetchMegaboxBookingList({
+    const { keyword, latitude, longitude, playDate = toYyyymmdd(), areaCode, limit = 10, timeoutMs = 15000, } = args;
+    const result = await fetchMegaboxNearbyTheaters({
+        keyword,
+        latitude,
+        longitude,
         playDate,
         areaCode,
+        limit,
+        timeout: timeoutMs,
+    }, {
+        googleMapsApiKey: process.env.GOOGLE_MAPS_API_KEY,
         timeout: timeoutMs,
     });
-    const infoResults = await Promise.allSettled(theaters.map((theater) => fetchMegaboxTheaterInfo(theater.theaterId, timeoutMs)));
-    const merged = theaters
-        .map((theater, index) => {
-        const infoResult = infoResults[index];
-        if (infoResult.status !== 'fulfilled') {
-            return null;
-        }
-        const info = infoResult.value;
-        if (info.latitude === null || info.longitude === null) {
-            return null;
-        }
-        const distanceKm = calculateDistanceKm(latitude, longitude, info.latitude, info.longitude);
-        return {
-            theaterId: theater.theaterId,
-            theaterName: theater.theaterName,
-            address: info.address,
-            latitude: info.latitude,
-            longitude: info.longitude,
-            distanceKm: Number(distanceKm.toFixed(2)),
-        };
-    })
-        .filter((theater) => theater !== null)
-        .sort((a, b) => a.distanceKm - b.distanceKm)
-        .slice(0, limit);
-    const result = {
-        location: { latitude, longitude },
-        playDate,
-        areaCode,
-        count: merged.length,
-        theaters: merged,
-    };
     return {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
@@ -59,8 +27,9 @@ export function createFindNearbyTheatersTool() {
         name: 'megabox_find_nearby_theaters',
         metadata: {
             title: '메가박스 주변 지점 탐색',
-            description: '사용자 좌표 기준으로 메가박스 지점을 거리순으로 조회합니다.',
+            description: '사용자 좌표 또는 위치 키워드 기준으로 메가박스 지점을 거리순으로 조회합니다.',
             inputSchema: {
+                keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 강남역)'),
                 latitude: z.number().optional().default(37.5665).describe('위도 (기본값: 서울 시청 37.5665)'),
                 longitude: z.number().optional().default(126.978).describe('경도 (기본값: 서울 시청 126.978)'),
                 playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),

package/dist/services/megabox/tools/getRemainingSeats.js

@@ -3,13 +3,34 @@
  */
 import * as z from 'zod';
 import { fetchMegaboxBookingList, toYyyymmdd } from '../client.js';
+import { resolveMegaboxNearestTheater } from '../location.js';
 async function getRemainingSeats(args) {
-    const { playDate = toYyyymmdd(), theaterId, movieId, areaCode = '11', limit = 50, timeoutMs = 15000, } = args;
+    const { playDate = toYyyymmdd(), theaterId: inputTheaterId, movieId, keyword, latitude, longitude, areaCode, limit = 50, timeoutMs = 15000, } = args;
+    let theaterId = inputTheaterId;
+    let resolvedTheater = null;
+    let resolvedLocation = null;
+    if (!theaterId && (typeof latitude === 'number' || typeof longitude === 'number' || (keyword || '').trim().length > 0)) {
+        const resolved = await resolveMegaboxNearestTheater({
+            keyword,
+            latitude,
+            longitude,
+            areaCode,
+            playDate,
+            timeout: timeoutMs,
+        }, {
+            googleMapsApiKey: process.env.GOOGLE_MAPS_API_KEY,
+            timeout: timeoutMs,
+        });
+        theaterId = resolved.theater?.theaterId;
+        resolvedTheater = resolved.theater;
+        resolvedLocation = resolved.location;
+    }
+    const resolvedAreaCode = resolvedLocation?.areaCode || areaCode || '11';
     const { showtimes } = await fetchMegaboxBookingList({
         playDate,
         theaterId,
         movieId,
-        areaCode,
+        areaCode: resolvedAreaCode,
         timeout: timeoutMs,
     });
     const filteredShowtimes = showtimes
@@ -27,9 +48,13 @@ async function getRemainingSeats(args) {
         filters: {
             theaterId: theaterId || null,
             movieId: movieId || null,
-            areaCode,
+            keyword: keyword || null,
+            latitude: typeof latitude === 'number' ? latitude : null,
+            longitude: typeof longitude === 'number' ? longitude : null,
+            areaCode: resolvedAreaCode,
             limit,
         },
+        resolvedTheater,
         count: filteredShowtimes.length,
         seats: filteredShowtimes,
     };
@@ -47,6 +72,9 @@ export function createGetRemainingSeatsTool() {
                 playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
                 theaterId: z.string().optional().describe('메가박스 지점 번호 (예: 1372)'),
                 movieId: z.string().optional().describe('메가박스 영화 번호 (예: 25104500)'),
+                keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 강남역)'),
+                latitude: z.number().optional().describe('위도'),
+                longitude: z.number().optional().describe('경도'),
                 areaCode: z.string().optional().default('11').describe('지역 코드 (기본값: 11, 서울)'),
                 limit: z.number().optional().default(50).describe('반환할 최대 회차 수 (기본값: 50)'),
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),

package/dist/services/megabox/tools/listNowShowing.js

@@ -3,13 +3,34 @@
  */
 import * as z from 'zod';
 import { fetchMegaboxBookingList, toYyyymmdd } from '../client.js';
+import { resolveMegaboxNearestTheater } from '../location.js';
 async function listNowShowing(args) {
-    const { playDate = toYyyymmdd(), theaterId, movieId, areaCode = '11', timeoutMs = 15000, } = args;
+    const { playDate = toYyyymmdd(), theaterId: inputTheaterId, movieId, keyword, latitude, longitude, areaCode, timeoutMs = 15000, } = args;
+    let theaterId = inputTheaterId;
+    let resolvedTheater = null;
+    let resolvedLocation = null;
+    if (!theaterId && (typeof latitude === 'number' || typeof longitude === 'number' || (keyword || '').trim().length > 0)) {
+        const resolved = await resolveMegaboxNearestTheater({
+            keyword,
+            latitude,
+            longitude,
+            areaCode,
+            playDate,
+            timeout: timeoutMs,
+        }, {
+            googleMapsApiKey: process.env.GOOGLE_MAPS_API_KEY,
+            timeout: timeoutMs,
+        });
+        theaterId = resolved.theater?.theaterId;
+        resolvedTheater = resolved.theater;
+        resolvedLocation = resolved.location;
+    }
+    const resolvedAreaCode = resolvedLocation?.areaCode || areaCode || '11';
     const { theaters, movies, showtimes } = await fetchMegaboxBookingList({
         playDate,
         theaterId,
         movieId,
-        areaCode,
+        areaCode: resolvedAreaCode,
         timeout: timeoutMs,
     });
     const result = {
@@ -17,8 +38,12 @@ async function listNowShowing(args) {
         filters: {
             theaterId: theaterId || null,
             movieId: movieId || null,
-            areaCode,
+            keyword: keyword || null,
+            latitude: typeof latitude === 'number' ? latitude : null,
+            longitude: typeof longitude === 'number' ? longitude : null,
+            areaCode: resolvedAreaCode,
         },
+        resolvedTheater,
         counts: {
             theaters: theaters.length,
             movies: movies.length,
@@ -42,6 +67,9 @@ export function createListNowShowingTool() {
                 playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
                 theaterId: z.string().optional().describe('메가박스 지점 번호 (예: 1372)'),
                 movieId: z.string().optional().describe('메가박스 영화 번호 (예: 25104500)'),
+                keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 강남역)'),
+                latitude: z.number().optional().describe('위도'),
+                longitude: z.number().optional().describe('경도'),
                 areaCode: z.string().optional().default('11').describe('지역 코드 (기본값: 11, 서울)'),
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },

package/dist/services/oliveyoung/api.js

@@ -5,4 +5,6 @@ export const OLIVEYOUNG_API = {
     BASE_URL: 'https://www.oliveyoung.co.kr',
     STORE_FINDER_PATH: '/oystore/api/storeFinder/find-store',
     PRODUCT_SEARCH_PATH: '/oystore/api/stock/product-search-v3',
+    STOCK_GOODS_INFO_PATH: '/oystore/api/stock/stock-goods-info-v3',
+    STOCK_STORES_PATH: '/oystore/api/stock/stock-stores',
 };

package/dist/services/oliveyoung/client.js

@@ -5,6 +5,61 @@
  */
 import { OLIVEYOUNG_API } from './api.js';
 import { decodeBase64, requestByZyte } from '../../utils/zyte.js';
+const OLIVEYOUNG_IMAGE_HOST = 'https://image.oliveyoung.co.kr';
+const OLIVEYOUNG_IMAGE_PATH_PREFIX = '/uploads/images/goods';
+function resolveOliveyoungInStock(o2oStockFlag, o2oRemainQuantity) {
+    return o2oStockFlag || o2oRemainQuantity > 0;
+}
+function resolveOliveyoungImageUrl(imagePath) {
+    if (!imagePath) {
+        return undefined;
+    }
+    if (/^https?:\/\//i.test(imagePath)) {
+        return imagePath;
+    }
+    if (imagePath.startsWith('//')) {
+        return `https:${imagePath}`;
+    }
+    const normalizedPath = imagePath.startsWith('/') ? imagePath : `/${imagePath}`;
+    if (normalizedPath.startsWith(`${OLIVEYOUNG_IMAGE_PATH_PREFIX}/`)) {
+        return `${OLIVEYOUNG_IMAGE_HOST}${normalizedPath}`;
+    }
+    return `${OLIVEYOUNG_IMAGE_HOST}${OLIVEYOUNG_IMAGE_PATH_PREFIX}${normalizedPath}`;
+}
+function resolveOliveyoungStoreQuantity(remainQuantity, o2oRemainQuantity) {
+    return Math.max(remainQuantity, o2oRemainQuantity);
+}
+function resolveOliveyoungStoreStock(rawStore) {
+    const remainQuantity = rawStore?.remainQuantity || 0;
+    const o2oRemainQuantity = rawStore?.o2oRemainQuantity || 0;
+    const quantity = resolveOliveyoungStoreQuantity(remainQuantity, o2oRemainQuantity);
+    const salesStoreYn = Boolean(rawStore?.salesStoreYn);
+    let stockStatus = 'out_of_stock';
+    let stockLabel = '품절';
+    if (!salesStoreYn) {
+        stockStatus = 'not_sold';
+        stockLabel = '미판매';
+    }
+    else if (quantity > 0) {
+        stockStatus = 'in_stock';
+        stockLabel = quantity >= 9 ? '재고 9개 이상' : `재고 ${quantity}개`;
+    }
+    return {
+        storeCode: rawStore?.storeCode || '',
+        storeName: rawStore?.storeName || '',
+        address: rawStore?.address || '',
+        latitude: rawStore?.latitude || 0,
+        longitude: rawStore?.longitude || 0,
+        distance: rawStore?.distance || 0,
+        pickupYn: Boolean(rawStore?.pickupYn),
+        salesStoreYn,
+        remainQuantity,
+        o2oRemainQuantity,
+        stockStatus,
+        stockLabel,
+        openYn: Boolean(rawStore?.openYn),
+    };
+}
 async function zyteExtract(targetPath, requestBody, options = {}) {
     const { timeout = 15000, apiKey } = options;
     try {
@@ -73,18 +128,104 @@ export async function fetchOliveyoungProducts(params, options = {}) {
     };
     const body = await zyteExtract(OLIVEYOUNG_API.PRODUCT_SEARCH_PATH, payload, options);
     const list = body.data?.serachList || body.data?.searchList || [];
-    const products = list.map((product) => ({
-        goodsNumber: product.goodsNumber || '',
-        goodsName: product.goodsName || '',
-        priceToPay: product.priceToPay || 0,
-        originalPrice: product.originalPrice || 0,
-        discountRate: product.discountRate || 0,
-        o2oStockFlag: Boolean(product.o2oStockFlag),
-        o2oRemainQuantity: product.o2oRemainQuantity || 0,
-    }));
+    const products = list.map((product) => {
+        const o2oStockFlag = Boolean(product.o2oStockFlag);
+        const o2oRemainQuantity = product.o2oRemainQuantity || 0;
+        const inStock = resolveOliveyoungInStock(o2oStockFlag, o2oRemainQuantity);
+        const stockStatus = inStock ? 'in_stock' : 'out_of_stock';
+        const stockSource = 'global_search';
+        return {
+            goodsNumber: product.goodsNumber || '',
+            goodsName: product.goodsName || '',
+            imageUrl: resolveOliveyoungImageUrl(product.imagePath),
+            priceToPay: product.priceToPay || 0,
+            originalPrice: product.originalPrice || 0,
+            discountRate: product.discountRate || 0,
+            o2oStockFlag,
+            o2oRemainQuantity,
+            inStock,
+            stockStatus,
+            stockSource,
+        };
+    });
     return {
         totalCount: body.data?.totalCount || 0,
         nextPage: Boolean(body.data?.nextPage),
         products,
     };
 }
+async function fetchOliveyoungProductId(goodsNumber, options = {}) {
+    const body = await zyteExtract(OLIVEYOUNG_API.STOCK_GOODS_INFO_PATH, { goodsNo: goodsNumber }, options);
+    return body.data?.goodsInfo?.masterGoodsNumber || '';
+}
+async function fetchOliveyoungStockStores(params, options = {}) {
+    const body = await zyteExtract(OLIVEYOUNG_API.STOCK_STORES_PATH, {
+        productId: params.productId,
+        lat: params.latitude,
+        lon: params.longitude,
+        pageIdx: params.pageIdx,
+        searchWords: params.searchWords,
+        mapLat: params.latitude,
+        mapLon: params.longitude,
+    }, options);
+    const stores = (body.data?.storeList || []).map((store) => resolveOliveyoungStoreStock(store));
+    const inStockCount = stores.filter((store) => store.stockStatus === 'in_stock').length;
+    const notSoldCount = stores.filter((store) => store.stockStatus === 'not_sold').length;
+    return {
+        totalCount: body.data?.totalCount || 0,
+        inStockCount,
+        outOfStockCount: stores.length - inStockCount - notSoldCount,
+        notSoldCount,
+        stores,
+    };
+}
+function sortOliveyoungProducts(products) {
+    const score = (product) => {
+        if (product.stockSource === 'nearby_store') {
+            return product.inStock ? 4 : 3;
+        }
+        return product.inStock ? 2 : 1;
+    };
+    return [...products].sort((left, right) => score(right) - score(left));
+}
+export async function enrichOliveyoungProductsWithNearbyStoreInventory(products, params, options = {}) {
+    const maxProducts = Math.max(0, Math.min(products.length, params.maxProducts));
+    if (maxProducts === 0) {
+        return { checkedCount: 0, products };
+    }
+    const enrichedProducts = [];
+    let checkedCount = 0;
+    for (const [index, product] of products.entries()) {
+        if (index >= maxProducts) {
+            enrichedProducts.push(product);
+            continue;
+        }
+        const productId = await fetchOliveyoungProductId(product.goodsNumber, options);
+        if (!productId) {
+            enrichedProducts.push(product);
+            continue;
+        }
+        const storeInventory = await fetchOliveyoungStockStores({
+            productId,
+            latitude: params.latitude,
+            longitude: params.longitude,
+            pageIdx: 1,
+            searchWords: params.storeKeyword,
+        }, options);
+        checkedCount += 1;
+        const inStock = storeInventory.inStockCount > 0;
+        const stockStatus = inStock ? 'in_stock' : 'out_of_stock';
+        const stockSource = 'nearby_store';
+        enrichedProducts.push({
+            ...product,
+            inStock,
+            stockStatus,
+            stockSource,
+            storeInventory,
+        });
+    }
+    return {
+        checkedCount,
+        products: sortOliveyoungProducts(enrichedProducts),
+    };
+}

package/dist/services/oliveyoung/index.js

@@ -3,11 +3,12 @@
  */
 import { createFindNearbyStoresTool } from './tools/findNearbyStores.js';
 import { createCheckInventoryTool } from './tools/checkInventory.js';
+import { createSearchProductsTool } from './tools/searchProducts.js';
 const OLIVEYOUNG_METADATA = {
     id: 'oliveyoung',
     name: '올리브영',
     version: '1.0.0',
-    description: '올리브영 주변 매장 탐색 및 재고 파악 서비스 (Zyte API 기반)',
+    description: '올리브영 상품 검색, 주변 매장 탐색 및 재고 파악 서비스 (Zyte API 기반)',
 };
 class OliveyoungService {
     options;
@@ -17,6 +18,7 @@ class OliveyoungService {
     }
     getTools() {
         return [
+            createSearchProductsTool(this.options.zyteApiKey),
             createFindNearbyStoresTool(this.options.zyteApiKey),
             createCheckInventoryTool(this.options.zyteApiKey),
         ];

package/dist/services/oliveyoung/tools/checkInventory.js

@@ -2,7 +2,7 @@
  * 올리브영 재고 파악 도구
  */
 import * as z from 'zod';
-import { fetchOliveyoungProducts, fetchOliveyoungStores } from '../client.js';
+import { enrichOliveyoungProductsWithNearbyStoreInventory, fetchOliveyoungProducts, fetchOliveyoungStores, } from '../client.js';
 async function checkInventory(args) {
     const { keyword, latitude = 37.5665, longitude = 126.978, storeKeyword = '', page = 1, size = 20, sort = '01', includeSoldOut = false, storeLimit = 10, timeoutMs = 15000, zyteApiKey, } = args;
     if (!keyword || keyword.trim().length === 0) {
@@ -29,7 +29,16 @@ async function checkInventory(args) {
             apiKey: zyteApiKey,
         }),
     ]);
-    const inStockProducts = productResult.products.filter((product) => product.o2oStockFlag || product.o2oRemainQuantity > 0);
+    const enrichedInventory = await enrichOliveyoungProductsWithNearbyStoreInventory(productResult.products, {
+        latitude,
+        longitude,
+        storeKeyword,
+        maxProducts: Math.min(productResult.products.length, 5),
+    }, {
+        timeout: timeoutMs,
+        apiKey: zyteApiKey,
+    });
+    const inStockProducts = enrichedInventory.products.filter((product) => product.inStock);
     const result = {
         keyword,
         searchOptions: {
@@ -51,9 +60,11 @@ async function checkInventory(args) {
         inventory: {
             totalCount: productResult.totalCount,
             nextPage: productResult.nextPage,
+            stockCheckedCount: enrichedInventory.checkedCount,
+            stockUncheckedCount: Math.max(0, productResult.products.length - enrichedInventory.checkedCount),
             inStockCount: inStockProducts.length,
-            outOfStockCount: productResult.products.length - inStockProducts.length,
-            products: productResult.products,
+            outOfStockCount: enrichedInventory.products.length - inStockProducts.length,
+            products: enrichedInventory.products,
         },
     };
     return {