daiso 1.0.4 → 1.0.5

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

@@ -0,0 +1,163 @@
+/**
+ * GS25 재고 확인 도구
+ */
+/* c8 ignore start */
+import * as z from 'zod';
+import { attachDistanceToGs25Stores, fetchGs25SearchProducts, fetchGs25Stores, filterGs25StoresByKeyword, geocodeGs25Address, selectGs25StoresForKeyword, sortGs25Stores, } from '../client.js';
+async function checkInventory(args) {
+    const { keyword, itemCode: providedItemCode, latitude, longitude, storeKeyword = '', serviceCode = '01', storeLimit = 20, timeoutMs = 20000, } = args;
+    if (!keyword || keyword.trim().length === 0) {
+        throw new Error('상품 검색어(keyword)를 입력해주세요.');
+    }
+    let resolvedLatitude = latitude;
+    let resolvedLongitude = longitude;
+    let geocodeUsed = false;
+    let itemCodeUsed = false;
+    let resolvedItemCode = null;
+    // 좌표가 없고 storeKeyword가 있으면 지오코딩 시도
+    if ((typeof resolvedLatitude !== 'number' || typeof resolvedLongitude !== 'number') &&
+        storeKeyword.trim().length > 0) {
+        const baseStores = await fetchGs25Stores({
+            serviceCode,
+        }, {
+            timeout: timeoutMs,
+        });
+        const firstAddress = filterGs25StoresByKeyword(baseStores.stores, storeKeyword).find((store) => store.address.trim().length > 0)
+            ?.address || '';
+        if (firstAddress.length > 0) {
+            const geocoded = await geocodeGs25Address(firstAddress, {
+                timeout: timeoutMs,
+                googleMapsApiKey: process.env.GOOGLE_MAPS_API_KEY,
+            });
+            if (geocoded) {
+                resolvedLatitude = geocoded.latitude;
+                resolvedLongitude = geocoded.longitude;
+                geocodeUsed = true;
+            }
+        }
+    }
+    // 좌표가 없으면 기본 좌표 (서울 강남) 사용
+    // itemCode 기반 재고 조회는 좌표가 필수
+    if (typeof resolvedLatitude !== 'number' || typeof resolvedLongitude !== 'number') {
+        resolvedLatitude = 37.4979;
+        resolvedLongitude = 127.0276;
+    }
+    let stockResult;
+    let firstProduct;
+    // itemCode가 직접 제공된 경우 totalSearch 단계 건너뛰기
+    if (providedItemCode && providedItemCode.trim().length > 0) {
+        resolvedItemCode = providedItemCode.trim();
+        itemCodeUsed = true;
+        stockResult = await fetchGs25Stores({
+            serviceCode,
+            itemCode: resolvedItemCode,
+            realTimeStockYn: 'Y',
+            latitude: resolvedLatitude,
+            longitude: resolvedLongitude,
+            useCache: false,
+        }, {
+            timeout: timeoutMs,
+        });
+    }
+    else {
+        // itemCode가 없으면 totalSearch API로 키워드 → itemCode 변환
+        const searchProducts = await fetchGs25SearchProducts(keyword, { timeout: timeoutMs });
+        firstProduct = searchProducts.find((p) => p.itemCode.length > 0);
+        if (firstProduct) {
+            resolvedItemCode = firstProduct.itemCode;
+            itemCodeUsed = true;
+            stockResult = await fetchGs25Stores({
+                serviceCode,
+                itemCode: resolvedItemCode,
+                realTimeStockYn: 'Y',
+                latitude: resolvedLatitude,
+                longitude: resolvedLongitude,
+                useCache: false,
+            }, {
+                timeout: timeoutMs,
+            });
+        }
+        else {
+            // itemCode가 없으면 기존 keyword 방식 fallback
+            stockResult = await fetchGs25Stores({
+                serviceCode,
+                keyword,
+                realTimeStockYn: 'Y',
+                latitude: resolvedLatitude,
+                longitude: resolvedLongitude,
+                useCache: false,
+            }, {
+                timeout: timeoutMs,
+            });
+        }
+    }
+    const selectedByStoreKeyword = selectGs25StoresForKeyword(stockResult.stores, storeKeyword, {
+        relaxWhenEmpty: typeof resolvedLatitude === 'number' && typeof resolvedLongitude === 'number',
+    });
+    const filteredByStoreKeyword = selectedByStoreKeyword.stores;
+    const withDistance = attachDistanceToGs25Stores(filteredByStoreKeyword, resolvedLatitude, resolvedLongitude);
+    const stores = sortGs25Stores(withDistance).slice(0, storeLimit);
+    const totalInStockCount = filteredByStoreKeyword.filter((item) => item.realStockQuantity > 0).length;
+    const totalStockQuantity = filteredByStoreKeyword.reduce((sum, item) => sum + Math.max(item.realStockQuantity, 0), 0);
+    // searchProducts에서 상품 정보 사용
+    const firstProductName = firstProduct?.itemName || firstProduct?.shortItemName || null;
+    const firstProductPrice = filteredByStoreKeyword.find((item) => item.searchItemSellPrice !== null)?.searchItemSellPrice ?? null;
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    serviceCode,
+                    keyword,
+                    itemCodeUsed,
+                    itemCode: resolvedItemCode,
+                    storeKeyword,
+                    geocodeUsed,
+                    filterRelaxed: selectedByStoreKeyword.filterRelaxed,
+                    location: {
+                        latitude: resolvedLatitude,
+                        longitude: resolvedLongitude,
+                    },
+                    product: {
+                        name: firstProductName,
+                        sellPrice: firstProductPrice,
+                        imageUrl: firstProduct?.imageUrl || null,
+                        rating: firstProduct?.rating || null,
+                    },
+                    inventory: {
+                        totalStoreCount: stockResult.totalCount,
+                        matchedStoreCount: filteredByStoreKeyword.length,
+                        inStockStoreCount: totalInStockCount,
+                        totalStockQuantity,
+                        count: stores.length,
+                        stores,
+                    },
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createCheckInventoryTool() {
+    return {
+        name: 'gs25_check_inventory',
+        metadata: {
+            title: 'GS25 재고 확인',
+            description: '상품 키워드 기준으로 GS25 매장별 재고를 조회합니다.',
+            inputSchema: {
+                keyword: z.string().describe('상품 검색어 (예: 오감자, 삼각김밥, 커피)'),
+                itemCode: z
+                    .string()
+                    .optional()
+                    .describe('상품 코드 (gs25_search_products로 조회한 정확한 코드, 제공 시 keyword 검색 건너뜀)'),
+                latitude: z.number().optional().describe('위도 (선택, 미입력 시 storeKeyword 지오코딩 시도)'),
+                longitude: z.number().optional().describe('경도 (선택, 미입력 시 storeKeyword 지오코딩 시도)'),
+                storeKeyword: z.string().optional().describe('매장명/주소 키워드 필터 (예: 강남, 안산 중앙역)'),
+                serviceCode: z.string().optional().default('01').describe('서비스 코드 (기본값: 01=GS25)'),
+                storeLimit: z.number().optional().default(20).describe('반환할 매장 수 (기본값: 20)'),
+                timeoutMs: z.number().optional().default(20000).describe('요청 제한 시간(ms, 기본값: 20000)'),
+            },
+        },
+        handler: checkInventory,
+    };
+}
+/* c8 ignore stop */

package/dist/services/gs25/tools/findNearbyStores.js

@@ -0,0 +1,103 @@
+/**
+ * GS25 주변 매장 탐색 도구
+ */
+import * as z from 'zod';
+import { attachDistanceToGs25Stores, fetchGs25Stores, geocodeGs25Address, selectGs25StoresForKeyword, sortGs25Stores, } from '../client.js';
+const FALLBACK_STORE_LOOKUP_ITEM_CODE = '8801117752804';
+async function findNearbyStores(args) {
+    const { latitude, longitude, keyword = '', serviceCode = '01', limit = 20, timeoutMs = 20000, } = args;
+    let resolvedLatitude = latitude;
+    let resolvedLongitude = longitude;
+    let geocodeUsed = false;
+    if ((typeof resolvedLatitude !== 'number' || typeof resolvedLongitude !== 'number') &&
+        keyword.trim().length > 0) {
+        const geocoded = await geocodeGs25Address(keyword, {
+            timeout: timeoutMs,
+            googleMapsApiKey: process.env.GOOGLE_MAPS_API_KEY,
+        });
+        if (geocoded) {
+            resolvedLatitude = geocoded.latitude;
+            resolvedLongitude = geocoded.longitude;
+            geocodeUsed = true;
+        }
+    }
+    let result = await fetchGs25Stores({
+        serviceCode,
+        latitude: resolvedLatitude,
+        longitude: resolvedLongitude,
+    }, {
+        timeout: timeoutMs,
+    });
+    let fallbackUsed = false;
+    if (result.stores.length === 0 &&
+        typeof resolvedLatitude === 'number' &&
+        typeof resolvedLongitude === 'number') {
+        try {
+            const fallbackResult = await fetchGs25Stores({
+                serviceCode,
+                itemCode: FALLBACK_STORE_LOOKUP_ITEM_CODE,
+                realTimeStockYn: 'Y',
+                latitude: resolvedLatitude,
+                longitude: resolvedLongitude,
+                useCache: false,
+            }, {
+                timeout: timeoutMs,
+            });
+            if (fallbackResult.stores.length > 0) {
+                result = fallbackResult;
+                fallbackUsed = true;
+            }
+        }
+        catch {
+            fallbackUsed = false;
+        }
+    }
+    const selected = selectGs25StoresForKeyword(result.stores, keyword, {
+        relaxWhenEmpty: typeof resolvedLatitude === 'number' && typeof resolvedLongitude === 'number',
+    });
+    const withDistance = attachDistanceToGs25Stores(selected.stores, resolvedLatitude, resolvedLongitude);
+    const stores = sortGs25Stores(withDistance).slice(0, limit);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    serviceCode,
+                    keyword,
+                    geocodeUsed,
+                    location: typeof resolvedLatitude === 'number' && typeof resolvedLongitude === 'number'
+                        ? {
+                            latitude: resolvedLatitude,
+                            longitude: resolvedLongitude,
+                        }
+                        : null,
+                    cacheHit: result.cacheHit,
+                    totalCount: result.totalCount,
+                    filteredCount: selected.stores.length,
+                    filterRelaxed: selected.filterRelaxed,
+                    fallbackUsed,
+                    count: stores.length,
+                    stores,
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createFindNearbyStoresTool() {
+    return {
+        name: 'gs25_find_nearby_stores',
+        metadata: {
+            title: 'GS25 주변 매장 탐색',
+            description: '좌표/키워드로 GS25 매장을 조회하고 거리순으로 정렬합니다.',
+            inputSchema: {
+                latitude: z.number().optional().describe('위도 (선택, 미입력 시 keyword 지오코딩 시도)'),
+                longitude: z.number().optional().describe('경도 (선택, 미입력 시 keyword 지오코딩 시도)'),
+                keyword: z.string().optional().describe('매장명/주소 키워드 (예: 강남, 안산 중앙역)'),
+                serviceCode: z.string().optional().default('01').describe('서비스 코드 (기본값: 01=GS25)'),
+                limit: z.number().optional().default(20).describe('반환할 최대 매장 수 (기본값: 20)'),
+                timeoutMs: z.number().optional().default(20000).describe('요청 제한 시간(ms, 기본값: 20000)'),
+            },
+        },
+        handler: findNearbyStores,
+    };
+}

package/dist/services/gs25/tools/searchProducts.js

@@ -0,0 +1,50 @@
+/**
+ * GS25 상품 키워드 검색 도구
+ */
+import * as z from 'zod';
+import { fetchGs25SearchProducts } from '../client.js';
+async function searchProducts(args) {
+    const { keyword, limit = 20, timeoutMs = 20000 } = args;
+    if (!keyword || keyword.trim().length === 0) {
+        throw new Error('상품 검색어(keyword)를 입력해주세요.');
+    }
+    const products = await fetchGs25SearchProducts(keyword, { timeout: timeoutMs });
+    const limitedProducts = products.slice(0, limit);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    keyword,
+                    count: limitedProducts.length,
+                    products: limitedProducts.map((p) => ({
+                        itemCode: p.itemCode,
+                        itemName: p.itemName,
+                        shortItemName: p.shortItemName,
+                        imageUrl: p.imageUrl,
+                        rating: p.rating,
+                        stockCheckEnabled: p.stockCheckEnabled,
+                    })),
+                    note: limitedProducts.length === 0
+                        ? '검색 결과가 없습니다. 다른 키워드로 검색해보세요.'
+                        : '재고 확인 시 itemCode를 gs25_check_inventory에 전달하면 정확한 상품 재고를 조회할 수 있습니다.',
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createSearchProductsTool() {
+    return {
+        name: 'gs25_search_products',
+        metadata: {
+            title: 'GS25 상품 키워드 검색',
+            description: '키워드로 GS25 상품을 검색하여 itemCode를 조회합니다. 재고 확인 전에 먼저 이 도구로 정확한 상품을 찾으세요.',
+            inputSchema: {
+                keyword: z.string().describe('상품 검색어 (예: 핫식스, 삼각김밥, 커피)'),
+                limit: z.number().optional().default(20).describe('반환할 최대 상품 수 (기본값: 20)'),
+                timeoutMs: z.number().optional().default(20000).describe('요청 제한 시간(ms, 기본값: 20000)'),
+            },
+        },
+        handler: searchProducts,
+    };
+}

package/dist/services/gs25/types.js

@@ -0,0 +1,4 @@
+/**
+ * GS25 서비스 전용 타입 정의
+ */
+export {};

package/dist/services/lottecinema/api.js

@@ -0,0 +1,12 @@
+/**
+ * 롯데시네마 API 엔드포인트 및 메서드 상수
+ */
+export const LOTTECINEMA_API = {
+    BASE_URL: 'https://www.lottecinema.co.kr',
+    TICKETING_PATH: '/LCWS/Ticketing/TicketingData.aspx',
+    MAIN_PATH: '/LCWS/Common/MainData.aspx',
+    METHODS: {
+        GET_TICKETING_PAGE: 'GetTicketingPageTOBE',
+        GET_PLAY_SEQUENCE: 'GetPlaySequence',
+    },
+};

package/dist/services/lottecinema/client.js

@@ -0,0 +1,161 @@
+/**
+ * 롯데시네마 API 클라이언트
+ */
+import { formatTime, toNumber, toYyyymmdd } from '../../utils/format.js';
+import { createTimeoutController } from '../../utils/http.js';
+import { LOTTECINEMA_API } from './api.js';
+const DEFAULT_OS_VERSION = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36';
+function normalizeDateForRequest(playDate) {
+    if (/^\d{8}$/.test(playDate)) {
+        return `${playDate.slice(0, 4)}-${playDate.slice(4, 6)}-${playDate.slice(6, 8)}`;
+    }
+    return playDate;
+}
+function normalizeDateForOutput(playDate) {
+    return playDate.replace(/-/g, '');
+}
+function toNullableNumber(value) {
+    if (value === null || value === undefined || value === '') {
+        return null;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function buildRequestPayload(methodName, fields) {
+    return {
+        MethodName: methodName,
+        channelType: 'HO',
+        osType: 'W',
+        osVersion: DEFAULT_OS_VERSION,
+        ...fields,
+    };
+}
+async function requestLotteCinema(methodName, fields, timeout = 15000) {
+    const { controller, timeoutId } = createTimeoutController(timeout);
+    try {
+        const body = new FormData();
+        body.append('paramList', JSON.stringify(buildRequestPayload(methodName, fields)));
+        const response = await fetch(`${LOTTECINEMA_API.BASE_URL}${LOTTECINEMA_API.TICKETING_PATH}`, {
+            method: 'POST',
+            headers: {
+                Accept: 'application/json, text/javascript, */*; q=0.01',
+            },
+            body,
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`롯데시네마 API 호출 실패: ${response.status}`);
+        }
+        const parsed = (await response.json());
+        if (parsed.IsOK === false) {
+            throw new Error(`롯데시네마 API 응답 실패: ${parsed.ResultMessage || 'UNKNOWN'}`);
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error('롯데시네마 API 호출 시간 초과');
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+function buildCompositeCinemaId(theater) {
+    return `${theater.regionCode}|${theater.regionDetailCode}|${theater.theaterId}`;
+}
+function buildScheduleId(playDate, theaterId, screenId, playSequence) {
+    return `${playDate}-${theaterId}-${screenId}-${playSequence}`;
+}
+export async function fetchLotteCinemaTicketingPage(timeout = 15000) {
+    const response = await requestLotteCinema(LOTTECINEMA_API.METHODS.GET_TICKETING_PAGE, {
+        memberOnNo: '0',
+    }, timeout);
+    const theaters = Array.from(new Map((response.Cinemas?.Cinemas?.Items || [])
+        .filter((item) => item.CinemaID && item.CinemaNameKR && item.DivisionCode && item.DetailDivisionCode)
+        .map((item) => ({
+        theaterId: String(item.CinemaID),
+        theaterName: item.CinemaNameKR,
+        regionCode: String(item.DivisionCode),
+        regionDetailCode: String(item.DetailDivisionCode),
+        latitude: toNullableNumber(item.Latitude),
+        longitude: toNullableNumber(item.Longitude),
+        address: item.CinemaAddrSummary || '',
+    }))
+        .map((theater) => [theater.theaterId, theater])).values());
+    const movies = (response.Movies?.Movies?.Items || [])
+        .filter((item) => item.RepresentationMovieCode && item.MovieNameKR)
+        .map((item) => ({
+        movieId: String(item.RepresentationMovieCode),
+        movieName: item.MovieNameKR,
+        rating: item.ViewGradeNameKR || undefined,
+        durationMinutes: item.PlayTime === null || item.PlayTime === undefined ? undefined : toNumber(item.PlayTime),
+        releaseDate: item.ReleaseDate || undefined,
+    }));
+    return { theaters, movies };
+}
+async function fetchPlaySequenceByPair(playDate, theater, movie, timeout = 15000) {
+    const response = await requestLotteCinema(LOTTECINEMA_API.METHODS.GET_PLAY_SEQUENCE, {
+        playDate: normalizeDateForRequest(playDate),
+        cinemaID: buildCompositeCinemaId(theater),
+        representationMovieCode: movie.movieId,
+    }, timeout);
+    return (response.PlaySeqs?.Items || [])
+        .filter((item) => item.CinemaID && item.RepresentationMovieCode && item.ScreenID && item.PlaySequence)
+        .map((item) => {
+        const totalSeats = toNumber(item.TotalSeatCount);
+        const bookedSeats = toNumber(item.BookingSeatCount);
+        const normalizedPlayDate = normalizeDateForOutput(item.PlayDt || playDate);
+        const theaterId = String(item.CinemaID);
+        const screenId = String(item.ScreenID);
+        const playSequence = String(item.PlaySequence);
+        return {
+            scheduleId: buildScheduleId(normalizedPlayDate, theaterId, screenId, playSequence),
+            theaterId,
+            theaterName: item.CinemaNameKR || theater.theaterName,
+            movieId: String(item.RepresentationMovieCode),
+            movieName: item.MovieNameKR || movie.movieName,
+            screenId,
+            screenName: item.ScreenNameKR || '',
+            playDate: normalizedPlayDate,
+            startTime: formatTime(item.StartTime),
+            endTime: formatTime(item.EndTime),
+            totalSeats,
+            bookedSeats,
+            remainingSeats: Math.max(totalSeats - bookedSeats, 0),
+        };
+    });
+}
+export async function fetchLotteCinemaNowShowing(params) {
+    const playDate = params.playDate || toYyyymmdd();
+    const timeout = params.timeout || 15000;
+    const ticketingPage = await fetchLotteCinemaTicketingPage(timeout);
+    if (!params.theaterId && !params.movieId) {
+        return {
+            theaters: ticketingPage.theaters,
+            movies: ticketingPage.movies,
+            showtimes: [],
+        };
+    }
+    const theaters = params.theaterId
+        ? ticketingPage.theaters.filter((theater) => theater.theaterId === params.theaterId)
+        : ticketingPage.theaters;
+    const movies = params.movieId
+        ? ticketingPage.movies.filter((movie) => movie.movieId === params.movieId)
+        : ticketingPage.movies;
+    if (theaters.length === 0 || movies.length === 0) {
+        return { theaters, movies, showtimes: [] };
+    }
+    const targets = theaters.flatMap((theater) => movies.map((movie) => ({ theater, movie })));
+    const results = await Promise.all(targets.map(({ theater, movie }) => fetchPlaySequenceByPair(playDate, theater, movie, timeout)));
+    const uniqueShowtimes = Array.from(new Map(results.flat().map((item) => [item.scheduleId, item])).values());
+    const theaterIds = new Set(uniqueShowtimes.map((item) => item.theaterId));
+    const movieIds = new Set(uniqueShowtimes.map((item) => item.movieId));
+    return {
+        theaters: ticketingPage.theaters.filter((theater) => params.theaterId ? theater.theaterId === params.theaterId : theaterIds.has(theater.theaterId)),
+        movies: ticketingPage.movies.filter((movie) => params.movieId ? movie.movieId === params.movieId : movieIds.has(movie.movieId)),
+        showtimes: uniqueShowtimes,
+    };
+}
+export { toYyyymmdd };

package/dist/services/lottecinema/index.js

@@ -0,0 +1,30 @@
+/**
+ * 롯데시네마 서비스 프로바이더
+ */
+import { createFindNearbyTheatersTool } from './tools/findNearbyTheaters.js';
+import { createGetRemainingSeatsTool } from './tools/getRemainingSeats.js';
+import { createListNowShowingTool } from './tools/listNowShowing.js';
+const LOTTECINEMA_METADATA = {
+    id: 'lottecinema',
+    name: '롯데시네마',
+    version: '1.0.0',
+    description: '롯데시네마 주변 지점 탐색, 영화 목록 조회, 잔여 좌석 조회 서비스',
+};
+class LotteCinemaService {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    metadata = LOTTECINEMA_METADATA;
+    getTools() {
+        return [
+            createFindNearbyTheatersTool(this.options.googleMapsApiKey),
+            createListNowShowingTool(this.options.googleMapsApiKey),
+            createGetRemainingSeatsTool(this.options.googleMapsApiKey),
+        ];
+    }
+}
+export function createLotteCinemaService(options = {}) {
+    return new LotteCinemaService(options);
+}
+export * from './types.js';