daiso 1.0.4 → 1.0.5

package/dist/services/seveneleven/productKeyword.js

@@ -0,0 +1,141 @@
+/**
+ * 세븐일레븐 상품 검색어 보정
+ */
+import { searchSevenElevenProducts } from './client.js';
+const SANDWICH_SUFFIX_FAMILY = ['샌드위치', '샌드', '산도'];
+function normalizeProductText(value) {
+    return value.replace(/[^0-9A-Za-z가-힣]+/g, '').toLowerCase();
+}
+function removeSuffixFamily(value) {
+    for (const suffix of SANDWICH_SUFFIX_FAMILY) {
+        if (value.endsWith(suffix)) {
+            return value.slice(0, -suffix.length);
+        }
+    }
+    return value;
+}
+/**
+ * 세븐일레븐 상품 검색용 보정 질의를 생성합니다.
+ */
+export function buildSevenElevenProductKeywordVariants(rawKeyword) {
+    const base = rawKeyword.trim();
+    if (!base) {
+        return [];
+    }
+    const compact = base.replace(/\s+/g, '');
+    const stem = removeSuffixFamily(compact);
+    const candidates = [base, compact];
+    if (stem && stem !== compact) {
+        candidates.push(stem);
+        for (const suffix of SANDWICH_SUFFIX_FAMILY) {
+            candidates.push(`${stem}${suffix}`);
+        }
+        candidates.push('샌드');
+    }
+    return [...new Set(candidates.map((value) => value.trim()).filter((value) => value.length > 0))];
+}
+/**
+ * 원본 검색어 기준으로 가장 그럴듯한 상품을 고릅니다.
+ */
+export function pickBestSevenElevenProduct(products, rawKeyword) {
+    let bestProduct = null;
+    let bestScore = -1;
+    for (const product of products) {
+        const score = scoreSevenElevenProduct(product, rawKeyword);
+        if (score > bestScore) {
+            bestScore = score;
+            bestProduct = product;
+        }
+    }
+    return bestScore > 0 ? bestProduct : null;
+}
+function scoreSevenElevenProduct(product, rawKeyword) {
+    const original = normalizeProductText(rawKeyword);
+    const stem = normalizeProductText(removeSuffixFamily(rawKeyword.replace(/\s+/g, '')));
+    const variants = buildSevenElevenProductKeywordVariants(rawKeyword)
+        .map(normalizeProductText)
+        .filter((value) => value.length > 0);
+    const hasSandwichSuffix = stem.length > 0 && stem !== original;
+    const normalizedName = normalizeProductText(product.itemName);
+    if (normalizedName.length === 0) {
+        return -1;
+    }
+    let score = 0;
+    if (original.length > 0 && normalizedName === original) {
+        score += 200;
+    }
+    if (original.length > 0 && normalizedName.includes(original)) {
+        score += 120;
+    }
+    if (stem.length > 0 && stem !== original && normalizedName.includes(stem)) {
+        score += 45;
+    }
+    for (const variant of variants) {
+        if (variant.length < 2 || variant === original || variant === stem) {
+            continue;
+        }
+        if (normalizedName.includes(variant)) {
+            score += 15;
+        }
+    }
+    if (hasSandwichSuffix && SANDWICH_SUFFIX_FAMILY.some((suffix) => normalizedName.includes(suffix))) {
+        score += 35;
+    }
+    if (hasSandwichSuffix &&
+        stem.length > 0 &&
+        SANDWICH_SUFFIX_FAMILY.some((suffix) => normalizedName.includes(`${stem}${suffix}`))) {
+        score += 50;
+    }
+    if (product.itemCode.length > 0) {
+        score += 1;
+    }
+    return score;
+}
+/**
+ * 보정 질의를 순차 적용해 세븐일레븐 상품을 찾습니다.
+ */
+export async function searchSevenElevenProductsWithVariants(query, options = {}) {
+    const { page = 1, size = 20, sort = 'recommend', timeout } = options;
+    const appliedQueries = buildSevenElevenProductKeywordVariants(query);
+    const seenKeys = new Set();
+    const collectionIds = new Set();
+    const mergedProducts = [];
+    for (const candidate of appliedQueries) {
+        const result = await searchSevenElevenProducts({
+            query: candidate,
+            page,
+            size,
+            sort,
+        }, {
+            timeout,
+        });
+        for (const collectionId of result.collectionIds) {
+            collectionIds.add(collectionId);
+        }
+        for (const product of result.products) {
+            const key = product.itemCode || product.productNo || product.itemName;
+            if (!key || seenKeys.has(key)) {
+                continue;
+            }
+            seenKeys.add(key);
+            mergedProducts.push(product);
+        }
+    }
+    const rankedProducts = [...mergedProducts].sort((left, right) => {
+        const leftScore = scoreSevenElevenProduct(left, query);
+        const rightScore = scoreSevenElevenProduct(right, query);
+        if (leftScore !== rightScore) {
+            return rightScore - leftScore;
+        }
+        return 0;
+    });
+    const start = Math.max(page - 1, 0) * size;
+    const pagedProducts = rankedProducts.slice(start, start + size);
+    return {
+        query,
+        totalCount: rankedProducts.length,
+        products: pagedProducts,
+        collectionIds: [...collectionIds],
+        appliedQueries,
+    };
+}

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

@@ -0,0 +1,82 @@
+/**
+ * 세븐일레븐 재고 확인 도구
+ *
+ * 상품 검색 + 매장 검색을 결합하여 특정 지역 매장의 재고를 조회합니다.
+ * 재고 API가 암호화로 차단된 경우에도 상품/매장 정보를 함께 제공합니다.
+ */
+/* c8 ignore start */
+import * as z from 'zod';
+import { checkSevenElevenInventory } from '../inventory.js';
+function isEncryptedStockFailure(stockError) {
+    if (!stockError) {
+        return false;
+    }
+    const codeMatched = stockError.code === 501 || stockError.code === 503;
+    const messageSource = `${stockError.message} ${stockError.raw ?? ''}`;
+    const messageMatched = /RSA|복호화|암호화|서비스를 사용할 수 없습니다/i.test(messageSource);
+    return codeMatched || messageMatched;
+}
+async function checkInventory(args) {
+    const { keyword, storeKeyword = '', storeLimit = 20, timeoutMs = 20000, } = args;
+    if (!keyword || keyword.trim().length === 0) {
+        throw new Error('상품 검색어(keyword)를 입력해주세요.');
+    }
+    const result = await checkSevenElevenInventory({
+        productKeyword: keyword,
+        storeKeyword,
+        storeLimit,
+    }, {
+        timeout: timeoutMs,
+    });
+    const note = !result.product
+        ? '상품 검색 결과가 없어 재고를 조회하지 못했습니다. 다른 상품명이나 더 짧은 키워드로 다시 시도해주세요.'
+        : result.stockAvailable
+            ? '실시간 재고 데이터가 포함되어 있습니다.'
+            : isEncryptedStockFailure(result.stockError)
+                ? '실시간 재고 API가 암호화 검증에서 거절되었습니다. 현재 구현의 평문 요청만으로는 재고 수량을 조회할 수 없습니다.'
+                : result.stockError
+                    ? `실시간 재고 API 호출에 실패했습니다: ${result.stockError.message}`
+                    : '실시간 재고 API가 현재 제한되어 있어 매장 목록만 제공됩니다. stockQuantity가 -1인 경우 재고 수량 미확인 상태입니다.';
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    keyword,
+                    storeKeyword,
+                    product: result.product,
+                    stockAvailable: result.stockAvailable,
+                    stockError: result.stockError,
+                    note,
+                    inventory: {
+                        totalStoreCount: result.totalStoreCount,
+                        inStockStoreCount: result.inStockStoreCount,
+                        count: result.stores.length,
+                        stores: result.stores,
+                    },
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createCheckInventoryTool() {
+    return {
+        name: 'seveneleven_check_inventory',
+        metadata: {
+            title: '세븐일레븐 재고 확인',
+            description: '상품 키워드와 매장/지역 키워드로 세븐일레븐 매장별 재고를 조회합니다. 실시간 재고 API가 제한된 경우에도 상품 정보와 근처 매장 목록을 함께 제공합니다.',
+            inputSchema: {
+                keyword: z.string().describe('상품 검색어 (예: 핫식스, 삼각김밥, 도시락)'),
+                storeKeyword: z
+                    .string()
+                    .optional()
+                    .default('')
+                    .describe('매장/지역 검색 키워드 (예: 안산 중앙역, 강남역, 홍대)'),
+                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/seveneleven/tools/getCatalogSnapshot.js

@@ -0,0 +1,55 @@
+/**
+ * 세븐일레븐 카탈로그 스냅샷 도구
+ */
+import * as z from 'zod';
+import { fetchSevenElevenCatalogSnapshot } from '../client.js';
+async function getCatalogSnapshot(args) {
+    const { includeIssues = true, includeExhibition = true, limit = 20, timeoutMs = 15000 } = args;
+    const result = await fetchSevenElevenCatalogSnapshot({
+        includeIssues,
+        includeExhibition,
+        timeout: timeoutMs,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    options: {
+                        includeIssues,
+                        includeExhibition,
+                        limit,
+                    },
+                    pages: {
+                        totalCount: result.pages.length,
+                        items: result.pages.slice(0, limit),
+                    },
+                    issues: {
+                        totalCount: result.issues.length,
+                        items: result.issues.slice(0, limit),
+                    },
+                    exhibitions: {
+                        totalCount: result.exhibitions.length,
+                        items: result.exhibitions.slice(0, limit),
+                    },
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createGetCatalogSnapshotTool() {
+    return {
+        name: 'seveneleven_get_catalog_snapshot',
+        metadata: {
+            title: '세븐일레븐 카탈로그 스냅샷',
+            description: '세븐일레븐 공개 카탈로그(페이지/이슈/기획전) 데이터를 조회합니다.',
+            inputSchema: {
+                includeIssues: z.boolean().optional().default(true).describe('이슈 상품 포함 여부 (기본값: true)'),
+                includeExhibition: z.boolean().optional().default(true).describe('기획전 포함 여부 (기본값: true)'),
+                limit: z.number().optional().default(20).describe('각 목록 최대 반환 수 (기본값: 20)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: getCatalogSnapshot,
+    };
+}

package/dist/services/seveneleven/tools/getSearchPopwords.js

@@ -0,0 +1,41 @@
+/**
+ * 세븐일레븐 인기 검색어 조회 도구
+ */
+import * as z from 'zod';
+import { fetchSevenElevenSearchPopwords } from '../client.js';
+async function getSearchPopwords(args) {
+    const { label = 'home', timeoutMs = 15000 } = args;
+    const keywords = await fetchSevenElevenSearchPopwords(label, {
+        timeout: timeoutMs,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    label,
+                    available: keywords.length > 0,
+                    count: keywords.length,
+                    keywords,
+                    note: keywords.length === 0
+                        ? '현재 응답에서 인기 검색어 목록을 찾지 못했습니다.'
+                        : '홈 인기 검색어를 조회했습니다.',
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createGetSearchPopwordsTool() {
+    return {
+        name: 'seveneleven_get_search_popwords',
+        metadata: {
+            title: '세븐일레븐 인기 검색어 조회',
+            description: '세븐일레븐 인기 검색어 목록을 조회합니다.',
+            inputSchema: {
+                label: z.string().optional().default('home').describe('조회 라벨 (기본값: home)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: getSearchPopwords,
+    };
+}

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

@@ -0,0 +1,56 @@
+/**
+ * 세븐일레븐 상품 검색 도구
+ */
+import * as z from 'zod';
+import { searchSevenElevenProductsWithVariants } from '../productKeyword.js';
+async function searchProducts(args) {
+    const { query, page = 1, size = 20, sort = 'recommend', timeoutMs = 15000 } = args;
+    if (!query || query.trim().length === 0) {
+        throw new Error('상품 검색어(query)를 입력해주세요.');
+    }
+    const result = await searchSevenElevenProductsWithVariants(query, {
+        page,
+        size,
+        sort,
+        timeout: timeoutMs,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    query: result.query,
+                    page,
+                    size,
+                    sort,
+                    totalCount: result.totalCount,
+                    count: result.products.length,
+                    collectionIds: result.collectionIds,
+                    appliedQueries: result.appliedQueries,
+                    products: result.products,
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createSearchProductsTool() {
+    return {
+        name: 'seveneleven_search_products',
+        metadata: {
+            title: '세븐일레븐 상품 검색',
+            description: '키워드로 세븐일레븐 상품을 검색합니다.',
+            inputSchema: {
+                query: z.string().describe('검색어 (예: 삼각김밥, 콜라, 도시락)'),
+                page: z.number().optional().default(1).describe('페이지 번호 (기본값: 1)'),
+                size: z.number().optional().default(20).describe('페이지당 결과 수 (기본값: 20)'),
+                sort: z
+                    .enum(['recommend', 'recent', 'popular'])
+                    .optional()
+                    .default('recommend')
+                    .describe('정렬 기준 (기본값: recommend)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: searchProducts,
+    };
+}

package/dist/services/seveneleven/tools/searchStores.js

@@ -0,0 +1,45 @@
+/**
+ * 세븐일레븐 매장 검색 도구
+ */
+import * as z from 'zod';
+import { fetchSevenElevenStoresByKeyword } from '../client.js';
+async function searchStores(args) {
+    const { keyword, limit = 20, timeoutMs = 15000 } = args;
+    if (!keyword || keyword.trim().length === 0) {
+        throw new Error('매장 검색어(keyword)를 입력해주세요.');
+    }
+    const result = await fetchSevenElevenStoresByKeyword({
+        keyword,
+        limit,
+    }, {
+        timeout: timeoutMs,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    keyword: result.query,
+                    totalCount: result.totalCount,
+                    count: result.stores.length,
+                    stores: result.stores,
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createSearchStoresTool() {
+    return {
+        name: 'seveneleven_search_stores',
+        metadata: {
+            title: '세븐일레븐 매장 검색',
+            description: '키워드로 세븐일레븐 매장을 검색합니다.',
+            inputSchema: {
+                keyword: z.string().describe('매장명/지역 키워드 (예: 안산 중앙역, 강남)'),
+                limit: z.number().optional().default(20).describe('반환할 최대 매장 수 (기본값: 20)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: searchStores,
+    };
+}

package/dist/services/seveneleven/types.js

@@ -0,0 +1,4 @@
+/**
+ * 세븐일레븐 타입 정의
+ */
+export {};

package/dist/utils/cliInteractiveHelpers.js

@@ -0,0 +1,63 @@
+/**
+ * 인터랙티브 CLI 보조 유틸
+ */
+import { buildDaisoStoreKeywordVariants } from './daisoKeyword.js';
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function toText(value) {
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return '';
+}
+export function parseStores(payload) {
+    if (!isRecord(payload) || payload.success !== true || !isRecord(payload.data)) {
+        return [];
+    }
+    const stores = payload.data.stores;
+    if (!Array.isArray(stores)) {
+        return [];
+    }
+    const result = [];
+    for (const store of stores) {
+        if (!isRecord(store)) {
+            continue;
+        }
+        const name = toText(store.name) || toText(store.storeName);
+        if (!name) {
+            continue;
+        }
+        result.push({
+            name,
+            address: toText(store.address),
+            phone: toText(store.phone),
+        });
+    }
+    return result;
+}
+export function parseDaisoProducts(payload) {
+    if (!isRecord(payload) || payload.success !== true || !isRecord(payload.data)) {
+        return [];
+    }
+    const products = payload.data.products;
+    if (!Array.isArray(products)) {
+        return [];
+    }
+    const result = [];
+    for (const product of products) {
+        if (!isRecord(product)) {
+            continue;
+        }
+        const id = toText(product.id);
+        const name = toText(product.name);
+        if (!id || !name) {
+            continue;
+        }
+        const priceRaw = product.price;
+        const price = typeof priceRaw === 'number' ? priceRaw : Number.parseInt(toText(priceRaw), 10) || 0;
+        result.push({ id, name, price });
+    }
+    return result;
+}
+export { buildDaisoStoreKeywordVariants };

package/dist/utils/daisoKeyword.js

@@ -0,0 +1,30 @@
+/**
+ * 다이소 매장 검색 키워드 보정
+ */
+/**
+ * 역/공백/서비스명이 섞인 검색어를 다이소 매장 검색용으로 보정합니다.
+ */
+export function buildDaisoStoreKeywordVariants(rawKeyword) {
+    const base = rawKeyword.trim();
+    if (!base) {
+        return [];
+    }
+    const compact = base.replace(/\s+/g, '');
+    const withoutNoise = compact.replace(/(다이소|근처|주변)/g, '');
+    const withoutStation = withoutNoise.replace(/역$/g, '');
+    const candidates = [
+        base,
+        compact,
+        withoutNoise,
+        withoutStation,
+        withoutStation.replace(/(중앙)(역)?$/g, '$1'),
+    ].map((item) => item.trim());
+    const unique = [];
+    for (const item of candidates) {
+        if (!item || unique.includes(item)) {
+            continue;
+        }
+        unique.push(item);
+    }
+    return unique;
+}

package/dist/utils/http.js

@@ -1,6 +1,20 @@
 /**
  * 공용 HTTP 유틸리티
  */
+export class HttpError extends Error {
+    status;
+    statusText;
+    bodyText;
+    constructor(status, statusText, bodyText) {
+        const normalizedBody = bodyText.trim().replace(/\s+/g, ' ').slice(0, 300);
+        const detail = normalizedBody.length > 0 ? ` - ${normalizedBody}` : '';
+        super(`API 요청 실패: ${status} ${statusText}${detail}`);
+        this.name = 'HttpError';
+        this.status = status;
+        this.statusText = statusText;
+        this.bodyText = bodyText;
+    }
+}
 export function createTimeoutController(timeout) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
@@ -22,14 +36,14 @@ export async function fetchWithTimeout(url, options = {}) {
 export async function fetchJson(url, options = {}) {
     const response = await fetchWithTimeout(url, options);
     if (!response.ok) {
-        throw new Error(`API 요청 실패: ${response.status} ${response.statusText}`);
+        throw new HttpError(response.status, response.statusText, await response.text());
     }
     return response.json();
 }
 export async function fetchText(url, options = {}) {
     const response = await fetchWithTimeout(url, options);
     if (!response.ok) {
-        throw new Error(`API 요청 실패: ${response.status} ${response.statusText}`);
+        throw new HttpError(response.status, response.statusText, await response.text());
     }
     return response.text();
 }