daiso 1.0.4 → 1.0.6

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,35 +1,121 @@
 /**
  * 공용 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);
     return { controller, timeoutId };
 }
-export async function fetchWithTimeout(url, options = {}) {
-    const { timeout = 10000, ...restOptions } = options;
-    const { controller, timeoutId } = createTimeoutController(timeout);
-    try {
-        return await fetch(url, {
-            ...restOptions,
-            signal: controller.signal,
-        });
+const DEFAULT_RETRY_STATUS_CODES = [408, 429, 500, 502, 503, 504, 522, 524];
+const DEFAULT_RETRY_METHODS = ['GET', 'HEAD', 'OPTIONS'];
+function isRetryableStatus(status, retryStatusCodes) {
+    return retryStatusCodes.includes(status);
+}
+function wait(ms) {
+    if (ms <= 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function normalizeMethod(method) {
+    return (method || 'GET').toUpperCase();
+}
+function canRetryMethod(method, retryMethods, retryUnsafeMethods) {
+    return retryUnsafeMethods || retryMethods.map((item) => item.toUpperCase()).includes(method);
+}
+function parseRetryAfterDelayMs(response) {
+    const retryAfter = response.headers.get('retry-after');
+    if (!retryAfter) {
+        return null;
+    }
+    const seconds = Number.parseFloat(retryAfter);
+    if (Number.isFinite(seconds)) {
+        return Math.max(0, Math.trunc(seconds * 1000));
     }
-    finally {
-        clearTimeout(timeoutId);
+    const retryDate = Date.parse(retryAfter);
+    if (Number.isFinite(retryDate)) {
+        return Math.max(0, retryDate - Date.now());
+    }
+    return null;
+}
+export async function fetchWithTimeout(url, options = {}) {
+    const { timeout = 10000, retries = 0, retryDelayMs = 250, retryStatusCodes = DEFAULT_RETRY_STATUS_CODES, retryUnsafeMethods = false, retryMethods = DEFAULT_RETRY_METHODS, onRetry, ...restOptions } = options;
+    const maxAttempts = Math.max(1, Math.trunc(retries) + 1);
+    const method = normalizeMethod(restOptions.method);
+    const retryAllowed = canRetryMethod(method, retryMethods, retryUnsafeMethods);
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        const { controller, timeoutId } = createTimeoutController(timeout);
+        try {
+            const response = await fetch(url, {
+                ...restOptions,
+                signal: controller.signal,
+            });
+            if (retryAllowed && attempt < maxAttempts && isRetryableStatus(response.status, retryStatusCodes)) {
+                const delayMs = parseRetryAfterDelayMs(response) ?? retryDelayMs;
+                onRetry?.({
+                    attempt,
+                    maxAttempts,
+                    delayMs,
+                    reason: 'status',
+                    status: response.status,
+                    method,
+                    url,
+                });
+                await response.body?.cancel();
+                await wait(delayMs);
+                continue;
+            }
+            return response;
+        }
+        catch (error) {
+            if (!retryAllowed || attempt >= maxAttempts) {
+                throw error;
+            }
+            onRetry?.({
+                attempt,
+                maxAttempts,
+                delayMs: retryDelayMs,
+                reason: 'error',
+                error,
+                method,
+                url,
+            });
+            await wait(retryDelayMs);
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
     }
+    /* v8 ignore next */
+    throw new Error('API 요청 재시도 처리 중 알 수 없는 오류가 발생했습니다.');
 }
 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();
 }

package/dist/utils/zyte.js

@@ -37,36 +37,57 @@ export function decodeBase64(value) {
     /* c8 ignore end */
     throw new Error('Base64 디코딩을 지원하지 않는 런타임입니다.');
 }
+function isAbortError(error) {
+    return error instanceof Error && error.name === 'AbortError';
+}
+function wait(ms) {
+    if (ms <= 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
 export async function requestByZyte(options) {
-    const { timeout = 15000, url, method = 'GET', headers = [], bodyText, apiKey } = options;
+    const { timeout = 15000, retries = 1, retryDelayMs = 250, url, method = 'GET', headers = [], bodyText, apiKey, } = options;
     const auth = encodeBasicAuth(resolveZyteApiKey(apiKey));
-    const { controller, timeoutId } = createTimeoutController(timeout);
-    try {
-        const response = await fetch('https://api.zyte.com/v1/extract', {
-            method: 'POST',
-            headers: {
-                Authorization: `Basic ${auth}`,
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-            },
-            body: JSON.stringify({
-                url,
-                httpRequestMethod: method,
-                customHttpRequestHeaders: headers,
-                httpRequestText: bodyText,
-                httpResponseBody: true,
-            }),
-            signal: controller.signal,
-        });
-        const result = (await response.json());
-        if (!response.ok) {
-            throw new Error(`Zyte API 호출 실패: ${response.status} ${result.detail || result.title || ''}`.trim());
+    const maxAttempts = Math.max(1, Math.trunc(retries) + 1);
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        const { controller, timeoutId } = createTimeoutController(timeout);
+        try {
+            const response = await fetch('https://api.zyte.com/v1/extract', {
+                method: 'POST',
+                headers: {
+                    Authorization: `Basic ${auth}`,
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json',
+                },
+                body: JSON.stringify({
+                    url,
+                    httpRequestMethod: method,
+                    customHttpRequestHeaders: headers,
+                    httpRequestText: bodyText,
+                    httpResponseBody: true,
+                }),
+                signal: controller.signal,
+            });
+            const result = (await response.json());
+            if (!response.ok) {
+                throw new Error(`Zyte API 호출 실패: ${response.status} ${result.detail || result.title || ''}`.trim());
+            }
+            return result;
+        }
+        catch (error) {
+            if (!isAbortError(error) || attempt >= maxAttempts) {
+                throw error;
+            }
+            await wait(retryDelayMs);
+        }
+        finally {
+            clearTimeout(timeoutId);
         }
-        return result;
-    }
-    finally {
-        clearTimeout(timeoutId);
     }
+    throw new Error('Zyte API 호출 실패');
 }
 export function decodeZyteHttpBody(result) {
     if (!result.httpResponseBody) {