daiso 1.0.0

package/dist/services/cgv/client.js

@@ -0,0 +1,146 @@
+/**
+ * CGV API 클라이언트
+ */
+import { formatTime, toNumber, toYyyymmdd } from '../../utils/format.js';
+import { CGV_API } from './api.js';
+import { requestCgv } from './transport.js';
+const DEFAULT_THEATER_CODE = '0056';
+const MAX_FALLBACK_THEATERS = 5;
+async function resolveTheaterCode(playDate, theaterCode, params) {
+    if (theaterCode) {
+        return theaterCode;
+    }
+    const theaters = await fetchCgvTheaters({
+        playDate,
+        regionCode: params.regionCode,
+        timeout: params.timeout,
+        zyteApiKey: params.zyteApiKey,
+    });
+    return theaters[0]?.theaterCode || DEFAULT_THEATER_CODE;
+}
+async function fetchMoviesByTheaterCode(playDate, theaterCode, params) {
+    const searchParams = new URLSearchParams({
+        coCd: CGV_API.COMPANY_CODE,
+        siteNo: theaterCode,
+        scnYmd: playDate,
+    });
+    const response = await requestCgv(CGV_API.MOVIE_LIST_PATH, searchParams, params.timeout, params.zyteApiKey);
+    return (response.data || [])
+        .filter((item) => item.movNo && item.movNm)
+        .map((item) => ({
+        movieCode: item.movNo,
+        movieName: item.movNm,
+        rating: item.cratgClsNm || undefined,
+    }));
+}
+async function fetchTimetableByMovieCode(playDate, theaterCode, movieCode, params) {
+    const searchParams = new URLSearchParams({
+        coCd: CGV_API.COMPANY_CODE,
+        siteNo: theaterCode,
+        scnYmd: playDate,
+        movNo: movieCode,
+        rtctlScopCd: CGV_API.TIMETABLE_SCOPE_CODE,
+    });
+    const response = await requestCgv(CGV_API.TIMETABLE_PATH, searchParams, params.timeout, params.zyteApiKey);
+    return (response.data || [])
+        .filter((item) => item.siteNo && item.movNo && item.scnYmd)
+        .map((item) => ({
+        scheduleId: `${item.scnYmd}${item.siteNo}${item.scnSseq || ''}`,
+        movieCode: item.movNo,
+        movieName: item.movNm || '',
+        theaterCode: item.siteNo,
+        theaterName: item.siteNm || '',
+        playDate: item.scnYmd,
+        startTime: formatTime(item.scnsrtTm),
+        endTime: formatTime(item.scnendTm),
+        totalSeats: toNumber(item.stcnt),
+        remainingSeats: toNumber(item.frSeatCnt || item.frtmpSeatCnt),
+    }));
+}
+async function fetchTimetableBySite(playDate, theaterCode, params) {
+    const searchParams = new URLSearchParams({
+        coCd: CGV_API.COMPANY_CODE,
+        siteNo: theaterCode,
+        scnYmd: playDate,
+        rtctlScopCd: CGV_API.TIMETABLE_SITE_SCOPE_CODE,
+    });
+    const response = await requestCgv(CGV_API.TIMETABLE_BY_SITE_PATH, searchParams, params.timeout, params.zyteApiKey);
+    return (response.data || [])
+        .filter((item) => item.siteNo && item.scnYmd)
+        .map((item) => ({
+        scheduleId: `${item.scnYmd}${item.siteNo}${item.scnSseq || ''}`,
+        movieCode: (item.movNo || ''),
+        movieName: item.movNm || item.prodNm || '',
+        theaterCode: item.siteNo,
+        theaterName: item.siteNm || '',
+        playDate: item.scnYmd,
+        startTime: formatTime(item.scnsrtTm),
+        endTime: formatTime(item.scnendTm),
+        totalSeats: toNumber(item.stcnt),
+        remainingSeats: toNumber(item.frSeatCnt || item.frtmpSeatCnt),
+    }));
+}
+export async function fetchCgvTheaters(params) {
+    const searchParams = new URLSearchParams({
+        coCd: CGV_API.COMPANY_CODE,
+    });
+    const response = await requestCgv(CGV_API.THEATER_LIST_PATH, searchParams, params.timeout, params.zyteApiKey);
+    const list = (response.data || []).flatMap((region) => (region.siteList || []).map((site) => ({
+        theaterCode: site.siteNo || '',
+        theaterName: site.siteNm || '',
+        regionCode: region.regnGrpCd || undefined,
+        regionName: region.regnGrpNm || '',
+    })));
+    return list
+        .filter((item) => item.theaterCode && item.theaterName)
+        .filter((item) => (params.regionCode ? item.regionCode === params.regionCode : true))
+        .map(({ theaterCode, theaterName, regionCode }) => ({ theaterCode, theaterName, regionCode }));
+}
+export async function fetchCgvMovies(params) {
+    const playDate = params.playDate || toYyyymmdd();
+    const theaterCode = await resolveTheaterCode(playDate, params.theaterCode, params);
+    return fetchMoviesByTheaterCode(playDate, theaterCode, params);
+}
+function pickFallbackTheaterCodes(theaters) {
+    const uniqueCodes = theaters
+        .map((theater) => theater.theaterCode)
+        .filter((code, index, array) => code && array.indexOf(code) === index);
+    return [DEFAULT_THEATER_CODE, ...uniqueCodes.filter((code) => code !== DEFAULT_THEATER_CODE)].slice(0, MAX_FALLBACK_THEATERS);
+}
+export async function fetchCgvTimetable(params) {
+    const playDate = params.playDate || toYyyymmdd();
+    const theaterCode = await resolveTheaterCode(playDate, params.theaterCode, params);
+    const timetableBySite = await fetchTimetableBySite(playDate, theaterCode, params);
+    if (timetableBySite.length > 0) {
+        if (params.movieCode) {
+            return timetableBySite.filter((item) => item.movieCode === params.movieCode);
+        }
+        return timetableBySite;
+    }
+    if (params.movieCode) {
+        return fetchTimetableByMovieCode(playDate, theaterCode, params.movieCode, params);
+    }
+    const theaterCodes = params.theaterCode
+        ? [params.theaterCode]
+        : pickFallbackTheaterCodes(await fetchCgvTheaters({
+            playDate,
+            regionCode: params.regionCode,
+            timeout: params.timeout,
+            zyteApiKey: params.zyteApiKey,
+        }));
+    for (const theaterCode of theaterCodes) {
+        const movies = await fetchMoviesByTheaterCode(playDate, theaterCode, params);
+        const timetableByTheater = [];
+        for (const movie of movies) {
+            const timetable = await fetchTimetableByMovieCode(playDate, theaterCode, movie.movieCode, params);
+            if (timetable.length > 0) {
+                timetableByTheater.push(...timetable);
+            }
+        }
+        if (timetableByTheater.length > 0) {
+            return timetableByTheater;
+        }
+    }
+    return [];
+}
+export { toYyyymmdd };

package/dist/services/cgv/index.js

@@ -0,0 +1,30 @@
+/**
+ * CGV 서비스 프로바이더
+ */
+import { createFindTheatersTool } from './tools/findTheaters.js';
+import { createSearchMoviesTool } from './tools/searchMovies.js';
+import { createGetTimetableTool } from './tools/getTimetable.js';
+const CGV_METADATA = {
+    id: 'cgv',
+    name: 'CGV',
+    version: '1.0.0',
+    description: 'CGV 극장 검색, 영화 검색, 시간표 조회 서비스',
+};
+class CgvService {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    metadata = CGV_METADATA;
+    getTools() {
+        return [
+            createFindTheatersTool(this.options.zyteApiKey),
+            createSearchMoviesTool(this.options.zyteApiKey),
+            createGetTimetableTool(this.options.zyteApiKey),
+        ];
+    }
+}
+export function createCgvService(options = {}) {
+    return new CgvService(options);
+}
+export * from './types.js';

package/dist/services/cgv/timetable.js

@@ -0,0 +1,16 @@
+/**
+ * CGV 시간표 후처리 유틸리티
+ */
+export function filterAndSortTimetable(timetable, options) {
+    const { theaterCode, movieCode, limit } = options;
+    return timetable
+        .filter((item) => (theaterCode ? item.theaterCode === theaterCode : true))
+        .filter((item) => (movieCode ? item.movieCode === movieCode : true))
+        .sort((a, b) => {
+        if (a.startTime === b.startTime) {
+            return a.theaterName.localeCompare(b.theaterName);
+        }
+        return a.startTime.localeCompare(b.startTime);
+    })
+        .slice(0, limit);
+}

package/dist/services/cgv/tools/findTheaters.js

@@ -0,0 +1,43 @@
+/**
+ * CGV 극장 검색 도구
+ */
+import * as z from 'zod';
+import { fetchCgvTheaters, toYyyymmdd } from '../client.js';
+async function findTheaters(args, apiKey) {
+    const { playDate = toYyyymmdd(), regionCode, limit = 30, timeoutMs = 15000 } = args;
+    const theaters = await fetchCgvTheaters({
+        playDate,
+        regionCode,
+        timeout: timeoutMs,
+        zyteApiKey: apiKey,
+    });
+    const sliced = theaters.slice(0, limit);
+    const result = {
+        playDate,
+        filters: {
+            regionCode: regionCode || null,
+            limit,
+        },
+        count: sliced.length,
+        theaters: sliced,
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+export function createFindTheatersTool(apiKey) {
+    return {
+        name: 'cgv_find_theaters',
+        metadata: {
+            title: 'CGV 극장 검색',
+            description: '지역 코드 기준으로 CGV 극장 목록을 조회합니다.',
+            inputSchema: {
+                playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
+                regionCode: z.string().optional().describe('지역 코드 (예: 01 서울)'),
+                limit: z.number().optional().default(30).describe('최대 결과 수 (기본값: 30)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: ((args) => findTheaters(args, apiKey)),
+    };
+}

package/dist/services/cgv/tools/getTimetable.js

@@ -0,0 +1,47 @@
+/**
+ * CGV 시간표 조회 도구
+ */
+import * as z from 'zod';
+import { fetchCgvTimetable, toYyyymmdd } from '../client.js';
+import { filterAndSortTimetable } from '../timetable.js';
+async function getTimetable(args, apiKey) {
+    const { playDate = toYyyymmdd(), theaterCode, movieCode, limit = 50, timeoutMs = 15000, } = args;
+    const timetable = await fetchCgvTimetable({
+        playDate,
+        theaterCode,
+        movieCode,
+        timeout: timeoutMs,
+        zyteApiKey: apiKey,
+    });
+    const filtered = filterAndSortTimetable(timetable, { theaterCode, movieCode, limit });
+    const result = {
+        playDate,
+        filters: {
+            theaterCode: theaterCode || null,
+            movieCode: movieCode || null,
+            limit,
+        },
+        count: filtered.length,
+        timetable: filtered,
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+export function createGetTimetableTool(apiKey) {
+    return {
+        name: 'cgv_get_timetable',
+        metadata: {
+            title: 'CGV 시간표 조회',
+            description: '날짜/극장/영화 조건으로 CGV 상영 시간표를 조회합니다.',
+            inputSchema: {
+                playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
+                theaterCode: z.string().optional().describe('CGV 극장 코드 (예: 0056)'),
+                movieCode: z.string().optional().describe('CGV 영화 코드'),
+                limit: z.number().optional().default(50).describe('최대 결과 수 (기본값: 50)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: ((args) => getTimetable(args, apiKey)),
+    };
+}

package/dist/services/cgv/tools/searchMovies.js

@@ -0,0 +1,40 @@
+/**
+ * CGV 영화 검색 도구
+ */
+import * as z from 'zod';
+import { fetchCgvMovies, toYyyymmdd } from '../client.js';
+async function searchMovies(args, apiKey) {
+    const { playDate = toYyyymmdd(), theaterCode, timeoutMs = 15000 } = args;
+    const movies = await fetchCgvMovies({
+        playDate,
+        theaterCode,
+        timeout: timeoutMs,
+        zyteApiKey: apiKey,
+    });
+    const result = {
+        playDate,
+        filters: {
+            theaterCode: theaterCode || null,
+        },
+        count: movies.length,
+        movies,
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+export function createSearchMoviesTool(apiKey) {
+    return {
+        name: 'cgv_search_movies',
+        metadata: {
+            title: 'CGV 영화 검색',
+            description: 'CGV 상영 영화 목록을 조회합니다.',
+            inputSchema: {
+                playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
+                theaterCode: z.string().optional().describe('CGV 극장 코드 (예: 0056)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: ((args) => searchMovies(args, apiKey)),
+    };
+}

package/dist/services/cgv/transport.js

@@ -0,0 +1,91 @@
+/**
+ * CGV 전송 계층
+ *
+ * 서명 헤더 생성, 직접 호출, Zyte fallback을 담당합니다.
+ */
+import { createTimeoutController } from '../../utils/http.js';
+import { decodeZyteHttpBody, requestByZyte } from '../../utils/zyte.js';
+import { CGV_API } from './api.js';
+function toBase64(bytes) {
+    /* c8 ignore start */
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(bytes).toString('base64');
+    }
+    /* c8 ignore end */
+    let binary = '';
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    if (typeof btoa === 'function') {
+        return btoa(binary);
+    }
+    /* c8 ignore next */
+    throw new Error('Base64 인코딩을 지원하지 않는 런타임입니다.');
+}
+async function createSignature(pathname, bodyText, timestamp) {
+    const payload = `${timestamp}|${pathname}|${bodyText}`;
+    const encoder = new TextEncoder();
+    const key = await crypto.subtle.importKey('raw', encoder.encode(CGV_API.SIGNING_SECRET), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+    const signed = await crypto.subtle.sign('HMAC', key, encoder.encode(payload));
+    return toBase64(new Uint8Array(signed));
+}
+async function parseJsonResponse(response) {
+    const text = await response.text();
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(text.slice(0, 120) || 'CGV API 응답 파싱 실패');
+    }
+}
+async function requestByZyteCgv(path, searchParams, timeout, apiKey) {
+    const url = `${CGV_API.BASE_URL}${path}?${searchParams.toString()}`;
+    const timestamp = Math.floor(Date.now() / 1000).toString();
+    const signature = await createSignature(path, '', timestamp);
+    const result = await requestByZyte({
+        apiKey,
+        timeout,
+        url,
+        headers: [
+            { name: 'Accept', value: 'application/json' },
+            { name: 'Accept-Language', value: 'ko-KR' },
+            { name: 'X-TIMESTAMP', value: timestamp },
+            { name: 'X-SIGNATURE', value: signature },
+        ],
+    });
+    return decodeZyteHttpBody(result);
+}
+export async function requestCgv(path, searchParams, timeout = 15000, zyteApiKey) {
+    const url = `${CGV_API.BASE_URL}${path}?${searchParams.toString()}`;
+    const timestamp = Math.floor(Date.now() / 1000).toString();
+    const signature = await createSignature(path, '', timestamp);
+    const { controller, timeoutId } = createTimeoutController(timeout);
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                Accept: 'application/json',
+                'Accept-Language': 'ko-KR',
+                'X-TIMESTAMP': timestamp,
+                'X-SIGNATURE': signature,
+            },
+            signal: controller.signal,
+        });
+        if (response.ok) {
+            return await parseJsonResponse(response);
+        }
+        if (response.status === 403 && zyteApiKey) {
+            return await requestByZyteCgv(path, searchParams, timeout, zyteApiKey);
+        }
+        throw new Error(`CGV API 호출 실패: ${response.status}`);
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error('CGV API 요청 시간 초과');
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}

package/dist/services/cgv/types.js

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

package/dist/services/daiso/api.js

@@ -0,0 +1,53 @@
+/**
+ * 다이소 API 엔드포인트 중앙 관리
+ *
+ * 모든 API URL을 한 곳에서 관리하여 유지보수성을 높입니다.
+ */
+/**
+ * 다이소몰 API (daisomall.co.kr)
+ * 상품 검색, 재고 조회 등
+ */
+export const DAISOMALL_API = {
+    /** 상품 검색 API */
+    SEARCH_PRODUCTS: 'https://prdm.daisomall.co.kr/ssn/search/FindStoreGoods',
+    /** 온라인 재고 조회 API */
+    ONLINE_STOCK: 'https://mapi.daisomall.co.kr/ms/msg/selOnlStck',
+    /** 매장별 재고 조회 API */
+    STORE_INVENTORY: 'https://mapi.daisomall.co.kr/ms/msg/newIntSelStr',
+    /** 이미지 CDN 베이스 URL */
+    IMAGE_BASE_URL: 'https://img.daisomall.co.kr',
+};
+/**
+ * 다이소 공식 사이트 API (daiso.co.kr)
+ * 매장 검색 등
+ */
+export const DAISO_WEB_API = {
+    /** 매장 검색 API */
+    SHOP_SEARCH: 'https://www.daiso.co.kr/cs/ajax/shop_search',
+    /** 시도별 구군 목록 조회 */
+    SIDO_SEARCH: 'https://www.daiso.co.kr/cs/ajax/sido_search',
+    /** 구군별 동 목록 조회 */
+    GUGUN_SEARCH: 'https://www.daiso.co.kr/cs/ajax/gugun_search',
+};
+/**
+ * 이미지 URL 생성 헬퍼
+ * @param path 이미지 경로 (API 응답에서 받은 상대 경로)
+ * @returns 전체 이미지 URL 또는 undefined
+ */
+export function getImageUrl(path) {
+    if (!path)
+        return undefined;
+    return `${DAISOMALL_API.IMAGE_BASE_URL}${path}`;
+}
+/**
+ * 영업 시간 포맷팅 헬퍼
+ * 4자리 숫자(예: 0900)를 시간 형식(예: 09:00)으로 변환
+ * @param time 4자리 시간 문자열
+ * @returns 포맷팅된 시간 문자열
+ */
+export function formatTime(time) {
+    if (time.length === 4) {
+        return `${time.slice(0, 2)}:${time.slice(2)}`;
+    }
+    return time;
+}

package/dist/services/daiso/client.js

@@ -0,0 +1,35 @@
+/**
+ * 다이소 HTTP 클라이언트
+ *
+ * 다이소 API 호출 시 필요한 기본 헤더를 적용합니다.
+ */
+import { fetchJson, fetchText, fetchWithTimeout } from '../../utils/http.js';
+const DAISO_DEFAULT_HEADERS = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    Accept: 'application/json, text/html, */*',
+    'Accept-Language': 'ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7',
+};
+function withDaisoHeaders(headers = {}) {
+    return {
+        ...DAISO_DEFAULT_HEADERS,
+        ...headers,
+    };
+}
+export async function daisoFetch(url, options = {}) {
+    return fetchWithTimeout(url, {
+        ...options,
+        headers: withDaisoHeaders(options.headers),
+    });
+}
+export async function fetchDaisoJson(url, options = {}) {
+    return fetchJson(url, {
+        ...options,
+        headers: withDaisoHeaders(options.headers),
+    });
+}
+export async function fetchDaisoHtml(url, options = {}) {
+    return fetchText(url, {
+        ...options,
+        headers: withDaisoHeaders(options.headers),
+    });
+}

package/dist/services/daiso/index.js

@@ -0,0 +1,42 @@
+/**
+ * 다이소 서비스 프로바이더
+ *
+ * 다이소 관련 모든 MCP 도구를 제공하는 서비스입니다.
+ */
+import { createSearchProductsTool } from './tools/searchProducts.js';
+import { createFindStoresTool } from './tools/findStores.js';
+import { createCheckInventoryTool } from './tools/checkInventory.js';
+import { createGetPriceInfoTool } from './tools/getPriceInfo.js';
+/**
+ * 다이소 서비스 메타데이터
+ */
+const DAISO_METADATA = {
+    id: 'daiso',
+    name: '다이소',
+    version: '1.0.0',
+    description: '다이소 제품 검색, 매장 검색, 재고 확인, 가격 조회 서비스',
+};
+/**
+ * 다이소 서비스 프로바이더 클래스
+ */
+class DaisoService {
+    metadata = DAISO_METADATA;
+    getTools() {
+        return [
+            createSearchProductsTool(),
+            createFindStoresTool(),
+            createCheckInventoryTool(),
+            createGetPriceInfoTool(),
+        ];
+    }
+}
+/**
+ * 다이소 서비스 팩토리 함수
+ * ServiceRegistry에 등록할 때 사용합니다.
+ */
+export function createDaisoService() {
+    return new DaisoService();
+}
+// 타입 및 유틸리티 재내보내기 (필요 시 사용)
+export * from './types.js';
+export { getImageUrl, formatTime } from './api.js';

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

@@ -0,0 +1,122 @@
+/**
+ * 재고 확인 도구
+ *
+ * 다이소몰 API를 사용하여 매장별 재고를 확인합니다.
+ */
+import * as z from 'zod';
+import { DAISOMALL_API } from '../api.js';
+import { fetchDaisoJson } from '../client.js';
+/**
+ * 온라인 재고 조회
+ */
+export async function fetchOnlineStock(productNo) {
+    const data = await fetchDaisoJson(DAISOMALL_API.ONLINE_STOCK, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ pdNo: productNo }),
+    });
+    if (!data.success) {
+        return 0;
+    }
+    return data.data?.stck || 0;
+}
+/**
+ * 매장별 재고 조회
+ */
+export async function fetchStoreInventory(productNo, lat, lng, page = 1, pageSize = 30, keyword = '') {
+    const data = await fetchDaisoJson(DAISOMALL_API.STORE_INVENTORY, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            keyword,
+            pdNo: productNo,
+            curLttd: lat,
+            curLitd: lng,
+            geolocationAgrYn: 'Y',
+            pkupYn: '',
+            intCd: '',
+            pageSize,
+            currentPage: page,
+        }),
+    });
+    if (!data.success || !data.data?.msStrVOList) {
+        return { stores: [], totalCount: 0 };
+    }
+    const stores = data.data.msStrVOList.map((store) => ({
+        storeCode: store.strCd,
+        storeName: store.strNm,
+        address: store.strAddr,
+        phone: store.strTno,
+        openTime: store.opngTime,
+        closeTime: store.clsngTime,
+        lat: store.strLttd,
+        lng: store.strLitd,
+        distance: store.km,
+        quantity: parseInt(store.qty) || 0,
+        options: {
+            parking: store.parkYn === 'Y',
+            simCard: store.usimYn === 'Y',
+            pickup: store.pkupYn === 'Y',
+            taxFree: store.taxfYn === 'Y',
+            elevator: store.elvtYn === 'Y',
+            ramp: store.entrRampYn === 'Y',
+            cashless: store.nocashYn === 'Y',
+        },
+    }));
+    return { stores, totalCount: data.data.intStrCont || stores.length };
+}
+/**
+ * 재고 확인 핸들러
+ */
+async function checkInventory(args) {
+    const { productId, storeQuery = '', latitude = 37.5665, // 기본값: 서울 시청
+    longitude = 126.978, page = 1, pageSize = 30, } = args;
+    if (!productId || productId.trim().length === 0) {
+        throw new Error('상품 ID(productId)를 입력해주세요.');
+    }
+    // 온라인 재고와 매장 재고 동시 조회
+    const [onlineStock, storeResult] = await Promise.all([
+        fetchOnlineStock(productId),
+        fetchStoreInventory(productId, latitude, longitude, page, pageSize, storeQuery),
+    ]);
+    // 재고 있는 매장과 없는 매장 분류
+    const inStockStores = storeResult.stores.filter((s) => s.quantity > 0);
+    const outOfStockStores = storeResult.stores.filter((s) => s.quantity === 0);
+    const result = {
+        productId,
+        location: { latitude, longitude },
+        onlineStock,
+        storeInventory: {
+            totalStores: storeResult.totalCount,
+            inStockCount: inStockStores.length,
+            outOfStockCount: outOfStockStores.length,
+            page,
+            pageSize,
+            stores: storeResult.stores,
+        },
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+/**
+ * 도구 등록 정보 생성
+ */
+export function createCheckInventoryTool() {
+    return {
+        name: 'daiso_check_inventory',
+        metadata: {
+            title: '재고 확인',
+            description: '특정 제품의 매장별 재고를 확인합니다. 매장명/주소 검색 또는 위치 기반으로 조회합니다.',
+            inputSchema: {
+                productId: z.string().describe('제품 ID (daiso_search_products로 조회한 상품의 id)'),
+                storeQuery: z.string().optional().describe('매장 검색어 (매장명 또는 주소, 예: 안산 중앙역)'),
+                latitude: z.number().optional().default(37.5665).describe('위도 (기본값: 서울 시청 37.5665)'),
+                longitude: z.number().optional().default(126.978).describe('경도 (기본값: 서울 시청 126.978)'),
+                page: z.number().optional().default(1).describe('페이지 번호 (기본값: 1)'),
+                pageSize: z.number().optional().default(30).describe('페이지당 결과 수 (기본값: 30)'),
+            },
+        },
+        handler: checkInventory,
+    };
+}