daiso 1.0.4 → 1.0.6

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,9 +2,9 @@
  * 올리브영 재고 파악 도구
  */
 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;
+    const { keyword, latitude = 37.5665, longitude = 126.978, storeKeyword = '', page = 1, size = 20, sort = '01', includeSoldOut = false, storeLimit = 10, stockCheckLimit = 5, timeoutMs = 15000, zyteApiKey, } = args;
     if (!keyword || keyword.trim().length === 0) {
         throw new Error('상품 검색어(keyword)를 입력해주세요.');
     }
@@ -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, Math.max(0, stockCheckLimit)),
+    }, {
+        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 {
@@ -79,6 +90,11 @@ export function createCheckInventoryTool(apiKey) {
                 sort: z.string().optional().default('01').describe('정렬 코드 (기본값: 01)'),
                 includeSoldOut: z.boolean().optional().default(false).describe('품절 상품 포함 여부 (기본값: false)'),
                 storeLimit: z.number().optional().default(10).describe('반환할 주변 매장 최대 수 (기본값: 10)'),
+                stockCheckLimit: z
+                    .number()
+                    .optional()
+                    .default(5)
+                    .describe('주변 매장별 재고를 보강할 상품 수 (기본값: 5, 낮출수록 빠름)'),
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },

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

@@ -0,0 +1,57 @@
+/**
+ * 올리브영 상품 검색 도구
+ */
+import * as z from 'zod';
+import { fetchOliveyoungProducts } from '../client.js';
+async function searchProducts(args) {
+    const { keyword, page = 1, size = 20, sort = '01', includeSoldOut = false, timeoutMs = 15000, zyteApiKey, } = args;
+    if (!keyword || keyword.trim().length === 0) {
+        throw new Error('상품 검색어(keyword)를 입력해주세요.');
+    }
+    const result = await fetchOliveyoungProducts({
+        keyword,
+        page,
+        size,
+        sort,
+        includeSoldOut,
+    }, {
+        timeout: timeoutMs,
+        apiKey: zyteApiKey,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    keyword,
+                    page,
+                    size,
+                    sort,
+                    includeSoldOut,
+                    totalCount: result.totalCount,
+                    nextPage: result.nextPage,
+                    count: result.products.length,
+                    products: result.products,
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createSearchProductsTool(apiKey) {
+    return {
+        name: 'oliveyoung_search_products',
+        metadata: {
+            title: '올리브영 상품 검색',
+            description: '키워드로 올리브영 상품 목록을 조회합니다. "어떤 거 있나요" 같은 질문에는 먼저 이 도구를 사용하세요.',
+            inputSchema: {
+                keyword: z.string().describe('상품 검색어 (예: 마스크팩, 선크림, 립밤)'),
+                page: z.number().optional().default(1).describe('상품 검색 페이지 번호 (기본값: 1)'),
+                size: z.number().optional().default(20).describe('페이지당 상품 수 (기본값: 20)'),
+                sort: z.string().optional().default('01').describe('정렬 코드 (기본값: 01)'),
+                includeSoldOut: z.boolean().optional().default(false).describe('품절 상품 포함 여부 (기본값: false)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: ((args) => searchProducts({ ...args, zyteApiKey: apiKey })),
+    };
+}

package/dist/services/seveneleven/api.js

@@ -0,0 +1,15 @@
+/**
+ * 세븐일레븐 API 엔드포인트
+ */
+export const SEVENELEVEN_API = {
+    BASE_URL: 'https://new.7-elevenapp.co.kr',
+    SEARCH_GOODS_PATH: '/api/v1/open/search/goods',
+    SEARCH_STORE_PATH: '/api/v1/open/search/store',
+    SEARCH_POPWORD_PATH: '/api/v1/open/search/popword',
+    PRODUCT_SEARCH_STOCK_PATH: '/api/v1/open/product/search/stock',
+    STOCK_SEARCH_STORES_PATH: '/api/v1/open/stock/search/stores',
+    REAL_STOCK_MULTI_PATH: '/api/v1/open/real-stock/multi',
+    PRODUCT_PAGES_PATH: '/api/v1/product/pages',
+    PRODUCT_ISSUES_PATH: '/api/v1/product/issues',
+    EXHIBITION_MAIN_PATH: '/api/v1/exhibition/main/list',
+};

package/dist/services/seveneleven/client.js

@@ -0,0 +1,286 @@
+/**
+ * 세븐일레븐 API 클라이언트
+ */
+/* c8 ignore start */
+import { fetchJson } from '../../utils/http.js';
+import { SEVENELEVEN_API } from './api.js';
+const SEVENELEVEN_DEFAULT_HEADERS = {
+    Accept: 'application/json, text/plain, */*',
+    'Content-Type': 'application/json',
+    'User-Agent': 'Mozilla/5.0 (Linux; Android 15)',
+};
+const SEVENELEVEN_DEFAULT_FETCH_OPTIONS = {
+    retries: 1,
+    retryDelayMs: 250,
+};
+function toNumber(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : 0;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number.parseFloat(value);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
+}
+function toStringValue(value) {
+    return typeof value === 'string' ? value : '';
+}
+function normalizeStoreKeyword(keyword) {
+    return keyword
+        .trim()
+        .replace(/\s+/g, '')
+        .replace(/(역|지점|점)$/g, '');
+}
+function toBooleanYn(value) {
+    const normalized = toStringValue(value).trim().toUpperCase();
+    return normalized === 'Y' || normalized === 'TRUE' || normalized === '1';
+}
+function toRawProduct(input) {
+    if (!input || typeof input !== 'object') {
+        return {};
+    }
+    const record = input;
+    if (record.field && typeof record.field === 'object') {
+        return record.field;
+    }
+    return record;
+}
+function normalizeProduct(raw) {
+    return {
+        productNo: toStringValue(raw.prdNo),
+        itemCode: toStringValue(raw.itemCd),
+        itemName: toStringValue(raw.itemOnm),
+        salePrice: toNumber(raw.onlinePrice),
+        originalPrice: toNumber(raw.onlineCost),
+        imageUrl: toStringValue(raw.repImgUrl),
+        eventName: toStringValue(raw.eventGbnNm),
+        itemType: toStringValue(raw.itemGbnNm),
+        makerName: toStringValue(raw.makerNm),
+        reviewScore: raw.avgEvalScore === undefined ? null : toNumber(raw.avgEvalScore),
+        reviewCount: toNumber(raw.productReviewCnt),
+    };
+}
+function normalizeProducts(items) {
+    return items
+        .map(toRawProduct)
+        .map(normalizeProduct)
+        .filter((item) => item.itemCode.length > 0 || item.itemName.length > 0);
+}
+function normalizeStore(raw) {
+    const address1 = toStringValue(raw.addr1);
+    const address2 = toStringValue(raw.addr2);
+    const mergedAddress = `${address1} ${address2}`.trim();
+    return {
+        storeCode: toStringValue(raw.storeCode || raw.storeCd || raw.strCd || raw.storCd || raw.shopCd),
+        storeName: toStringValue(raw.storeName || raw.storeNm || raw.strNm || raw.storNm || raw.shopNm),
+        address: toStringValue(raw.address || raw.addr || raw.roadAddr || raw.shopAddr) || mergedAddress,
+        latitude: toNumber(raw.latitude || raw.storeLat || raw.lat || raw.yPos || raw.y || raw.yCoord),
+        longitude: toNumber(raw.longitude || raw.storeLon || raw.lng || raw.xPos || raw.x || raw.xCoord),
+        pickupEnabled: toBooleanYn(raw.pickupEnabled || raw.pickupYn),
+        deliveryEnabled: toBooleanYn(raw.deliveryEnabled || raw.deliveryYn || raw.dlvyYn),
+        closeYn: toStringValue(raw.closeYn || raw.storeCloseYn || raw.closeYN || raw.clsYn),
+    };
+}
+function normalizeStockProductMeta(raw) {
+    return {
+        productNo: toStringValue(raw.prdNo),
+        itemCode: toStringValue(raw.itemCd),
+        itemName: toStringValue(raw.itemOnm),
+        smCode: toStringValue(raw.smCd),
+        stockManagementCode: toStringValue(raw.stokMngCd),
+        stockManagementQuantity: toNumber(raw.stokMngQty),
+        stockApplicationRate: toStringValue(raw.stockApplicationRate),
+    };
+}
+function normalizeStores(items) {
+    return items
+        .map((item) => {
+        if (!item || typeof item !== 'object') {
+            return {};
+        }
+        const record = item;
+        if (record.field && typeof record.field === 'object') {
+            return record.field;
+        }
+        return record;
+    })
+        .map(normalizeStore)
+        .filter((store) => store.storeCode.length > 0 || store.storeName.length > 0);
+}
+async function requestSevenElevenJson(path, method, body, options = {}) {
+    const { timeout = 15000 } = options;
+    const url = `${SEVENELEVEN_API.BASE_URL}${path}`;
+    return fetchJson(url, {
+        ...SEVENELEVEN_DEFAULT_FETCH_OPTIONS,
+        method,
+        retryUnsafeMethods: method === 'POST',
+        timeout,
+        headers: SEVENELEVEN_DEFAULT_HEADERS,
+        body: method === 'POST' ? JSON.stringify(body || {}) : undefined,
+    });
+}
+export async function searchSevenElevenProducts(params, options = {}) {
+    const { query, page = 1, size = 20 } = params;
+    const pageNo = Math.max(Math.trunc(page) - 1, 0);
+    const pageSize = Math.max(Math.trunc(size), 1);
+    const response = await requestSevenElevenJson(SEVENELEVEN_API.SEARCH_GOODS_PATH, 'POST', {
+        // 공개 검색 엔드포인트는 pageNo/pageSize만 안정적으로 동작한다.
+        // sort를 함께 보내면 빈 결과가 내려오는 케이스가 확인되어 제외한다.
+        query,
+        pageNo,
+        pageSize,
+    }, options);
+    const data = response.data || {};
+    const queryResult = data.SearchQueryResult;
+    const collections = queryResult?.Collection || [];
+    const collectionIds = collections.map((item) => item.CollectionId || '').filter((id) => id.length > 0);
+    let totalCount = 0;
+    const allDocuments = [];
+    for (const collection of collections) {
+        totalCount += toNumber(collection.Documentset?.totalCount);
+        allDocuments.push(...(collection.Documentset?.Document || []));
+    }
+    const collectionProducts = normalizeProducts(allDocuments);
+    const contentProducts = normalizeProducts(Array.isArray(data.content) ? data.content : []);
+    const products = (collectionProducts.length > 0 ? collectionProducts : contentProducts).slice(0, pageSize);
+    return {
+        query: queryResult?.query || query,
+        totalCount,
+        products,
+        collectionIds,
+    };
+}
+export async function fetchSevenElevenStoresByKeyword(params, options = {}) {
+    const { keyword, limit = 20 } = params;
+    const query = normalizeStoreKeyword(keyword) || keyword.trim();
+    const safeLimit = Number.isFinite(limit) ? Math.trunc(limit) : 20;
+    const listCount = Math.max(1, Math.min(safeLimit, 9999));
+    const response = await requestSevenElevenJson(SEVENELEVEN_API.SEARCH_STORE_PATH, 'POST', {
+        collection: 'store',
+        query,
+        sort: 'Date/desc',
+        listCount,
+    }, options);
+    const data = response.data || {};
+    const queryResult = data.SearchQueryResult;
+    const collections = queryResult?.Collection || [];
+    let totalCount = 0;
+    const allDocuments = [];
+    for (const collection of collections) {
+        totalCount += toNumber(collection.Documentset?.totalCount);
+        allDocuments.push(...(collection.Documentset?.Document || []));
+    }
+    const stores = normalizeStores(allDocuments);
+    return {
+        query: queryResult?.query || query,
+        totalCount,
+        stores,
+    };
+}
+export async function fetchSevenElevenSearchPopwords(label = 'home', options = {}) {
+    const encodedLabel = encodeURIComponent(label);
+    const response = await requestSevenElevenJson(`${SEVENELEVEN_API.SEARCH_POPWORD_PATH}?label=${encodedLabel}`, 'POST', {}, options);
+    const { data } = response;
+    if (Array.isArray(data)) {
+        return data.map((item) => toStringValue(item)).filter((item) => item.length > 0);
+    }
+    if (!data || typeof data !== 'object') {
+        return [];
+    }
+    const record = data;
+    const candidates = [record.keywords, record.popwords, record.wordList, record.list];
+    for (const candidate of candidates) {
+        if (!Array.isArray(candidate)) {
+            continue;
+        }
+        const values = candidate
+            .map((item) => {
+            if (typeof item === 'string') {
+                return item;
+            }
+            if (item && typeof item === 'object') {
+                const value = item;
+                return toStringValue(value.keyword || value.word || value.text || value.name);
+            }
+            return '';
+        })
+            .filter((item) => item.length > 0);
+        if (values.length > 0) {
+            return values;
+        }
+    }
+    return [];
+}
+export async function fetchSevenElevenStockProductMeta(itemCode, options = {}) {
+    const { timeout = 15000 } = options;
+    const encodedItemCode = encodeURIComponent(itemCode.trim());
+    const url = `${SEVENELEVEN_API.BASE_URL}${SEVENELEVEN_API.PRODUCT_SEARCH_STOCK_PATH}?itemCd=${encodedItemCode}`;
+    const response = await fetchJson(url, {
+        ...SEVENELEVEN_DEFAULT_FETCH_OPTIONS,
+        method: 'GET',
+        timeout,
+        headers: {
+            Accept: SEVENELEVEN_DEFAULT_HEADERS.Accept,
+            'User-Agent': SEVENELEVEN_DEFAULT_HEADERS['User-Agent'],
+        },
+    });
+    const productMeta = normalizeStockProductMeta(response);
+    if (productMeta.itemCode.length === 0 || productMeta.smCode.length === 0) {
+        return null;
+    }
+    return productMeta;
+}
+function normalizeExhibitions(items) {
+    return items
+        .map((item) => {
+        const value = (item || {});
+        const productList = Array.isArray(value.exhibitionProductList) ? value.exhibitionProductList : [];
+        return {
+            exhibitionIdx: toNumber(value.exhibitionIdx),
+            exhibitionName: toStringValue(value.exhibitionName),
+            startDate: toStringValue(value.exhibitionStartDate),
+            endDate: toStringValue(value.exhibitionEndDate),
+            productCount: productList.length,
+        };
+    })
+        .filter((item) => item.exhibitionIdx > 0 || item.exhibitionName.length > 0);
+}
+function extractContentArray(data) {
+    if (Array.isArray(data)) {
+        return data;
+    }
+    if (!data || typeof data !== 'object') {
+        return [];
+    }
+    const record = data;
+    if (Array.isArray(record.content)) {
+        return record.content;
+    }
+    if (Array.isArray(record.list)) {
+        return record.list;
+    }
+    return [];
+}
+export async function fetchSevenElevenCatalogSnapshot(options = {}) {
+    const { includeIssues = true, includeExhibition = true, timeout = 15000 } = options;
+    const tasks = [
+        requestSevenElevenJson(SEVENELEVEN_API.PRODUCT_PAGES_PATH, 'GET', null, { timeout }),
+        includeIssues
+            ? requestSevenElevenJson(SEVENELEVEN_API.PRODUCT_ISSUES_PATH, 'GET', null, { timeout })
+            : Promise.resolve({ data: { content: [] } }),
+        includeExhibition
+            ? requestSevenElevenJson(SEVENELEVEN_API.EXHIBITION_MAIN_PATH, 'GET', null, { timeout })
+            : Promise.resolve({ data: [] }),
+    ];
+    const [pagesResult, issuesResult, exhibitionsResult] = await Promise.allSettled(tasks);
+    const pagesData = pagesResult.status === 'fulfilled' ? pagesResult.value.data : [];
+    const issuesData = issuesResult.status === 'fulfilled' ? issuesResult.value.data : [];
+    const exhibitionData = exhibitionsResult.status === 'fulfilled' ? exhibitionsResult.value.data : [];
+    return {
+        pages: normalizeProducts(extractContentArray(pagesData)),
+        issues: normalizeProducts(extractContentArray(issuesData)),
+        exhibitions: normalizeExhibitions(extractContentArray(exhibitionData)),
+    };
+}
+/* c8 ignore stop */

package/dist/services/seveneleven/index.js

@@ -0,0 +1,30 @@
+/**
+ * 세븐일레븐 서비스 프로바이더
+ */
+import { createSearchProductsTool } from './tools/searchProducts.js';
+import { createSearchStoresTool } from './tools/searchStores.js';
+import { createCheckInventoryTool } from './tools/checkInventory.js';
+import { createGetSearchPopwordsTool } from './tools/getSearchPopwords.js';
+import { createGetCatalogSnapshotTool } from './tools/getCatalogSnapshot.js';
+const SEVENELEVEN_METADATA = {
+    id: 'seveneleven',
+    name: '세븐일레븐',
+    version: '1.0.0',
+    description: '세븐일레븐 공개 상품/검색/카탈로그 조회 서비스',
+};
+class SevenElevenService {
+    metadata = SEVENELEVEN_METADATA;
+    getTools() {
+        return [
+            createSearchProductsTool(),
+            createSearchStoresTool(),
+            createCheckInventoryTool(),
+            createGetSearchPopwordsTool(),
+            createGetCatalogSnapshotTool(),
+        ];
+    }
+}
+export function createSevenElevenService() {
+    return new SevenElevenService();
+}
+export * from './types.js';