daiso 1.0.3 → 1.0.5

package/dist/services/cgv/index.js

@@ -18,9 +18,9 @@ class CgvService {
     metadata = CGV_METADATA;
     getTools() {
         return [
-            createFindTheatersTool(this.options.zyteApiKey),
-            createSearchMoviesTool(this.options.zyteApiKey),
-            createGetTimetableTool(this.options.zyteApiKey),
+            createFindTheatersTool(this.options.zyteApiKey, this.options.googleMapsApiKey),
+            createSearchMoviesTool(this.options.zyteApiKey, this.options.googleMapsApiKey),
+            createGetTimetableTool(this.options.zyteApiKey, this.options.googleMapsApiKey),
         ];
     }
 }

package/dist/services/cgv/location.js

@@ -0,0 +1,235 @@
+/**
+ * CGV 위치 해석 및 근처 극장 조회 보조 모듈
+ */
+import { fetchJson } from '../../utils/http.js';
+import { fetchCgvTheaters } from './client.js';
+const DEFAULT_TIMEOUT_MS = 15000;
+const USER_GEOCODE_CACHE_TTL_MS = 60 * 60 * 1000;
+const THEATER_GEOCODE_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const MAX_CANDIDATE_THEATERS = 12;
+const LOCATION_STOPWORDS = new Set([
+    'cgv',
+    '극장',
+    '영화',
+    '주변',
+    '근처',
+    '오늘',
+    '상영',
+    '시간표',
+    '좌석',
+    '잔여',
+    '찾아',
+    '주세요',
+    '주세요요',
+    '역',
+]);
+const BRAND_PATTERN = /\b(?:cgv|씨지브이)\b/giu;
+const TRAILING_INTENT_PATTERN = /\s+(?:극장|영화관|영화|상영작|시간표|좌석|잔여좌석|남은좌석|목록|찾고|찾아|찾아서|알려|보여|추천|조회|확인|해주세요|해줘).*/u;
+const userGeocodeCache = new Map();
+const theaterGeocodeCache = new Map();
+function calculateDistanceKm(lat1, lng1, lat2, lng2) {
+    const toRad = (deg) => (deg * Math.PI) / 180;
+    const dLat = toRad(lat2 - lat1);
+    const dLng = toRad(lng2 - lng1);
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return 6371 * c;
+}
+function isValidCoordinate(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function normalizeWhitespace(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function normalizeText(text) {
+    return text.replace(/\s+/g, '').toLowerCase();
+}
+function sanitizeLocationKeyword(keyword) {
+    const trimmed = normalizeWhitespace(keyword);
+    if (trimmed.length === 0) {
+        return '';
+    }
+    let sanitized = normalizeWhitespace(trimmed.replace(BRAND_PATTERN, ' '));
+    const nearbyMatch = sanitized.match(/^(.+?)\s*(?:근처|주변)\s*(?:극장|영화관)?(?:\s.*)?$/u);
+    if (nearbyMatch?.[1]) {
+        sanitized = normalizeWhitespace(nearbyMatch[1]);
+    }
+    else {
+        sanitized = normalizeWhitespace(sanitized.replace(TRAILING_INTENT_PATTERN, ''));
+    }
+    return sanitized || trimmed;
+}
+function extractLocationTokens(...values) {
+    const tokens = new Set();
+    for (const value of values) {
+        const matches = (value || '').match(/[0-9A-Za-z가-힣]+/g) || [];
+        for (const match of matches) {
+            const normalized = normalizeText(match);
+            if (normalized.length < 2 || LOCATION_STOPWORDS.has(normalized)) {
+                continue;
+            }
+            tokens.add(normalized);
+        }
+    }
+    return [...tokens];
+}
+function scoreTheaterName(theaterName, tokens) {
+    const normalized = normalizeText(theaterName);
+    return tokens.reduce((score, token) => (normalized.includes(token) ? score + 1 : score), 0);
+}
+async function geocodeAddress(query, options, cacheKey, ttlMs, cache) {
+    const apiKey = (options.googleMapsApiKey || '').trim();
+    const trimmedQuery = query.trim();
+    if (apiKey.length === 0 || trimmedQuery.length === 0) {
+        return null;
+    }
+    const cached = cache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.value;
+    }
+    const endpoint = new URL('https://maps.googleapis.com/maps/api/geocode/json');
+    endpoint.searchParams.set('address', trimmedQuery);
+    endpoint.searchParams.set('key', apiKey);
+    const body = await fetchJson(endpoint.toString(), {
+        method: 'GET',
+        timeout: options.timeout || DEFAULT_TIMEOUT_MS,
+        headers: { Accept: 'application/json' },
+    });
+    const firstResult = body.status === 'OK' ? body.results?.[0] : null;
+    const latitude = firstResult?.geometry?.location?.lat;
+    const longitude = firstResult?.geometry?.location?.lng;
+    const value = typeof latitude === 'number' && typeof longitude === 'number'
+        ? {
+            latitude,
+            longitude,
+            formattedAddress: firstResult?.formatted_address || null,
+        }
+        : null;
+    cache.set(cacheKey, {
+        expiresAt: Date.now() + ttlMs,
+        value,
+    });
+    return value;
+}
+export async function resolveCgvLocation(params, options = {}) {
+    const keyword = sanitizeLocationKeyword((params.keyword || '').trim());
+    const hasCoordinates = isValidCoordinate(params.latitude) && isValidCoordinate(params.longitude);
+    if (hasCoordinates) {
+        return {
+            keyword: keyword.length > 0 ? keyword : null,
+            latitude: params.latitude,
+            longitude: params.longitude,
+            geocodeUsed: false,
+            formattedAddress: null,
+        };
+    }
+    if (keyword.length === 0) {
+        return {
+            keyword: null,
+            latitude: null,
+            longitude: null,
+            geocodeUsed: false,
+            formattedAddress: null,
+        };
+    }
+    const geocoded = await geocodeAddress(keyword, options, `user:${keyword}`, USER_GEOCODE_CACHE_TTL_MS, userGeocodeCache);
+    return {
+        keyword,
+        latitude: geocoded?.latitude ?? null,
+        longitude: geocoded?.longitude ?? null,
+        geocodeUsed: Boolean(geocoded),
+        formattedAddress: geocoded?.formattedAddress ?? null,
+    };
+}
+async function geocodeCgvTheater(theater, options) {
+    const cleanName = theater.theaterName.replace(/^CGV\s*/i, '').trim();
+    const geocoded = await geocodeAddress(`대한민국 CGV ${cleanName}`, options, `theater:${theater.theaterCode}:${cleanName}`, THEATER_GEOCODE_CACHE_TTL_MS, theaterGeocodeCache);
+    return geocoded
+        ? {
+            latitude: geocoded.latitude,
+            longitude: geocoded.longitude,
+            address: geocoded.formattedAddress,
+        }
+        : null;
+}
+function pickCandidateTheaters(theaters, tokens) {
+    if (tokens.length === 0) {
+        return theaters.slice(0, MAX_CANDIDATE_THEATERS);
+    }
+    const scored = theaters
+        .map((theater) => ({ theater, score: scoreTheaterName(theater.theaterName, tokens) }))
+        .filter((item) => item.score > 0)
+        .sort((left, right) => right.score - left.score || left.theater.theaterName.localeCompare(right.theater.theaterName))
+        .map((item) => item.theater);
+    return scored.slice(0, MAX_CANDIDATE_THEATERS);
+}
+export async function fetchCgvNearbyTheaters(params, options = {}) {
+    const limit = Math.max(1, params.limit || 10);
+    const timeout = params.timeout || DEFAULT_TIMEOUT_MS;
+    const theaters = await fetchCgvTheaters({
+        playDate: params.playDate,
+        regionCode: params.regionCode,
+        timeout,
+        zyteApiKey: options.zyteApiKey,
+    });
+    const location = await resolveCgvLocation(params, options);
+    const tokens = extractLocationTokens(location.keyword, location.formattedAddress);
+    const hasGoogleKey = (options.googleMapsApiKey || '').trim().length > 0;
+    if (tokens.length === 0 && !hasGoogleKey) {
+        return {
+            ...location,
+            playDate: params.playDate,
+            regionCode: params.regionCode || null,
+            count: 0,
+            theaters: [],
+        };
+    }
+    const candidates = pickCandidateTheaters(theaters, tokens);
+    const resolvedCandidates = await Promise.all(candidates.map(async (theater) => {
+        const geocoded = await geocodeCgvTheater(theater, options);
+        const distanceKm = geocoded && location.latitude !== null && location.longitude !== null
+            ? Number(calculateDistanceKm(location.latitude, location.longitude, geocoded.latitude, geocoded.longitude).toFixed(2))
+            : null;
+        return {
+            ...theater,
+            latitude: geocoded?.latitude ?? null,
+            longitude: geocoded?.longitude ?? null,
+            distanceKm,
+            address: geocoded?.address ?? null,
+        };
+    }));
+    const sorted = resolvedCandidates.sort((left, right) => {
+        const leftDistance = left.distanceKm ?? Number.POSITIVE_INFINITY;
+        const rightDistance = right.distanceKm ?? Number.POSITIVE_INFINITY;
+        return leftDistance - rightDistance || left.theaterName.localeCompare(right.theaterName);
+    });
+    return {
+        ...location,
+        playDate: params.playDate,
+        regionCode: params.regionCode || null,
+        count: sorted.slice(0, limit).length,
+        theaters: sorted.slice(0, limit),
+    };
+}
+export async function resolveCgvNearestTheater(params, options = {}) {
+    const nearby = await fetchCgvNearbyTheaters({
+        ...params,
+        limit: 1,
+        timeout: params.timeout,
+    }, options);
+    return {
+        location: {
+            keyword: nearby.keyword,
+            latitude: nearby.latitude,
+            longitude: nearby.longitude,
+            geocodeUsed: nearby.geocodeUsed,
+            formattedAddress: nearby.formattedAddress,
+        },
+        theater: nearby.theaters[0] || null,
+    };
+}
+export function __testOnlyClearCgvLocationCaches() {
+    userGeocodeCache.clear();
+    theaterGeocodeCache.clear();
+}

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

@@ -3,8 +3,27 @@
  */
 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;
+import { fetchCgvNearbyTheaters } from '../location.js';
+async function findTheaters(args, apiKey, googleMapsApiKey) {
+    const { playDate = toYyyymmdd(), regionCode, keyword, latitude, longitude, limit = 30, timeoutMs = 15000, } = args;
+    if (keyword || typeof latitude === 'number' || typeof longitude === 'number') {
+        const result = await fetchCgvNearbyTheaters({
+            playDate,
+            regionCode,
+            keyword,
+            latitude,
+            longitude,
+            limit,
+            timeout: timeoutMs,
+        }, {
+            timeout: timeoutMs,
+            zyteApiKey: apiKey,
+            googleMapsApiKey: googleMapsApiKey || process.env.GOOGLE_MAPS_API_KEY,
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    }
     const theaters = await fetchCgvTheaters({
         playDate,
         regionCode,
@@ -16,6 +35,9 @@ async function findTheaters(args, apiKey) {
         playDate,
         filters: {
             regionCode: regionCode || null,
+            keyword: keyword || null,
+            latitude: latitude ?? null,
+            longitude: longitude ?? null,
             limit,
         },
         count: sliced.length,
@@ -25,19 +47,22 @@ async function findTheaters(args, apiKey) {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
 }
-export function createFindTheatersTool(apiKey) {
+export function createFindTheatersTool(apiKey, googleMapsApiKey) {
     return {
         name: 'cgv_find_theaters',
         metadata: {
             title: 'CGV 극장 검색',
-            description: '지역 코드 기준으로 CGV 극장 목록을 조회합니다.',
+            description: '지역 코드 또는 위치 키워드 기준으로 CGV 극장 목록을 조회합니다.',
             inputSchema: {
                 playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
                 regionCode: z.string().optional().describe('지역 코드 (예: 01 서울)'),
+                keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 강남역)'),
+                latitude: z.number().optional().describe('위도'),
+                longitude: z.number().optional().describe('경도'),
                 limit: z.number().optional().default(30).describe('최대 결과 수 (기본값: 30)'),
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: ((args) => findTheaters(args, apiKey)),
+        handler: ((args) => findTheaters(args, apiKey, googleMapsApiKey)),
     };
 }

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

@@ -3,24 +3,49 @@
  */
 import * as z from 'zod';
 import { fetchCgvTimetable, toYyyymmdd } from '../client.js';
+import { resolveCgvNearestTheater } from '../location.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 });
+async function getTimetable(args, apiKey, googleMapsApiKey) {
+    const { playDate = toYyyymmdd(), theaterCode, movieCode, keyword, latitude, longitude, limit = 50, timeoutMs = 15000, } = args;
+    let resolvedTheater = null;
+    let targetTheaterCode = theaterCode;
+    if (!targetTheaterCode && (keyword || typeof latitude === 'number' || typeof longitude === 'number')) {
+        const resolved = await resolveCgvNearestTheater({
+            playDate,
+            keyword,
+            latitude,
+            longitude,
+            timeout: timeoutMs,
+        }, {
+            timeout: timeoutMs,
+            zyteApiKey: apiKey,
+            googleMapsApiKey: googleMapsApiKey || process.env.GOOGLE_MAPS_API_KEY,
+        });
+        resolvedTheater = resolved.theater;
+        targetTheaterCode = resolved.theater?.theaterCode;
+    }
+    const shouldReturnEmpty = !targetTheaterCode && (keyword || typeof latitude === 'number' || typeof longitude === 'number');
+    const timetable = shouldReturnEmpty
+        ? []
+        : await fetchCgvTimetable({
+            playDate,
+            theaterCode: targetTheaterCode,
+            movieCode,
+            timeout: timeoutMs,
+            zyteApiKey: apiKey,
+        });
+    const filtered = filterAndSortTimetable(timetable, { theaterCode: targetTheaterCode, movieCode, limit });
     const result = {
         playDate,
         filters: {
-            theaterCode: theaterCode || null,
+            theaterCode: targetTheaterCode || null,
             movieCode: movieCode || null,
+            keyword: keyword || null,
+            latitude: latitude ?? null,
+            longitude: longitude ?? null,
             limit,
         },
+        resolvedTheater,
         count: filtered.length,
         timetable: filtered,
     };
@@ -28,20 +53,23 @@ async function getTimetable(args, apiKey) {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
 }
-export function createGetTimetableTool(apiKey) {
+export function createGetTimetableTool(apiKey, googleMapsApiKey) {
     return {
         name: 'cgv_get_timetable',
         metadata: {
             title: 'CGV 시간표 조회',
-            description: '날짜/극장/영화 조건으로 CGV 상영 시간표를 조회합니다.',
+            description: '날짜/극장/영화 조건으로 CGV 상영 시간표를 조회합니다. 극장 코드가 없으면 위치 키워드 기준 최근접 극장을 선택할 수 있습니다.',
             inputSchema: {
                 playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
                 theaterCode: z.string().optional().describe('CGV 극장 코드 (예: 0056)'),
                 movieCode: z.string().optional().describe('CGV 영화 코드'),
+                keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 강남역)'),
+                latitude: z.number().optional().describe('위도'),
+                longitude: z.number().optional().describe('경도'),
                 limit: z.number().optional().default(50).describe('최대 결과 수 (기본값: 50)'),
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: ((args) => getTimetable(args, apiKey)),
+        handler: ((args) => getTimetable(args, apiKey, googleMapsApiKey)),
     };
 }

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

@@ -3,19 +3,44 @@
  */
 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,
-    });
+import { resolveCgvNearestTheater } from '../location.js';
+async function searchMovies(args, apiKey, googleMapsApiKey) {
+    const { playDate = toYyyymmdd(), theaterCode, keyword, latitude, longitude, timeoutMs = 15000 } = args;
+    let resolvedTheater = null;
+    let targetTheaterCode = theaterCode;
+    if (!targetTheaterCode && (keyword || typeof latitude === 'number' || typeof longitude === 'number')) {
+        const resolved = await resolveCgvNearestTheater({
+            playDate,
+            keyword,
+            latitude,
+            longitude,
+            timeout: timeoutMs,
+        }, {
+            timeout: timeoutMs,
+            zyteApiKey: apiKey,
+            googleMapsApiKey: googleMapsApiKey || process.env.GOOGLE_MAPS_API_KEY,
+        });
+        resolvedTheater = resolved.theater;
+        targetTheaterCode = resolved.theater?.theaterCode;
+    }
+    const shouldReturnEmpty = !targetTheaterCode && (keyword || typeof latitude === 'number' || typeof longitude === 'number');
+    const movies = shouldReturnEmpty
+        ? []
+        : await fetchCgvMovies({
+            playDate,
+            theaterCode: targetTheaterCode,
+            timeout: timeoutMs,
+            zyteApiKey: apiKey,
+        });
     const result = {
         playDate,
         filters: {
-            theaterCode: theaterCode || null,
+            theaterCode: targetTheaterCode || null,
+            keyword: keyword || null,
+            latitude: latitude ?? null,
+            longitude: longitude ?? null,
         },
+        resolvedTheater,
         count: movies.length,
         movies,
     };
@@ -23,18 +48,21 @@ async function searchMovies(args, apiKey) {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
 }
-export function createSearchMoviesTool(apiKey) {
+export function createSearchMoviesTool(apiKey, googleMapsApiKey) {
     return {
         name: 'cgv_search_movies',
         metadata: {
             title: 'CGV 영화 검색',
-            description: 'CGV 상영 영화 목록을 조회합니다.',
+            description: 'CGV 상영 영화 목록을 조회합니다. 극장 코드가 없으면 위치 키워드 기준 최근접 극장을 선택할 수 있습니다.',
             inputSchema: {
                 playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
                 theaterCode: z.string().optional().describe('CGV 극장 코드 (예: 0056)'),
+                keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 강남역)'),
+                latitude: z.number().optional().describe('위도'),
+                longitude: z.number().optional().describe('경도'),
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: ((args) => searchMovies(args, apiKey)),
+        handler: ((args) => searchMovies(args, apiKey, googleMapsApiKey)),
     };
 }

package/dist/services/cgv/transport.js

@@ -7,11 +7,9 @@ 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);
@@ -19,7 +17,6 @@ function toBase64(bytes) {
     if (typeof btoa === 'function') {
         return btoa(binary);
     }
-    /* c8 ignore next */
     throw new Error('Base64 인코딩을 지원하지 않는 런타임입니다.');
 }
 async function createSignature(pathname, bodyText, timestamp) {

package/dist/services/cu/api.js

@@ -0,0 +1,11 @@
+/**
+ * CU API 엔드포인트 중앙 관리
+ */
+export const CU_API = {
+    BASE_URL: 'https://www.pocketcu.co.kr',
+    STORE_PATH: '/api/store',
+    STOCK_DISPLAY_PATH: '/api/search/display/stock',
+    STOCK_MAIN_PATH: '/api/search/rest/stock/main',
+    WEB_BASE_URL: 'https://cu.bgfretail.com',
+    WEB_STORE_LIST_PATH: '/store/list_Ajax.do',
+};