daiso 1.0.4 → 1.0.6

package/dist/services/lottecinema/location.js

@@ -0,0 +1,191 @@
+/**
+ * 롯데시네마 위치 해석 및 근처 극장 조회 보조 모듈
+ */
+import { fetchJson } from '../../utils/http.js';
+import { fetchLotteCinemaTicketingPage } from './client.js';
+const DEFAULT_TIMEOUT_MS = 15000;
+const GEOCODE_CACHE_TTL_MS = 60 * 60 * 1000;
+const LOCATION_STOPWORDS = new Set([
+    '롯데시네마',
+    '영화',
+    '극장',
+    '주변',
+    '근처',
+    '오늘',
+    '상영',
+    '영화목록',
+    '시간표',
+    '좌석',
+    '잔여',
+    '찾아',
+    '주세요',
+]);
+const geocodeCache = 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 normalizeText(text) {
+    return text.replace(/\s+/g, '').toLowerCase();
+}
+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);
+            if (normalized.endsWith('역') && normalized.length > 2) {
+                tokens.add(normalized.slice(0, -1));
+            }
+        }
+    }
+    return [...tokens];
+}
+function scoreTheater(theater, tokens) {
+    const normalizedName = normalizeText(theater.theaterName);
+    const normalizedAddress = normalizeText(theater.address || '');
+    return tokens.reduce((score, token) => {
+        if (normalizedName.includes(token)) {
+            return score + 2;
+        }
+        if (normalizedAddress.includes(token)) {
+            return score + 1;
+        }
+        return score;
+    }, 0);
+}
+async function geocodeAddress(query, options) {
+    const apiKey = (options.googleMapsApiKey || '').trim();
+    const trimmedQuery = query.trim();
+    if (apiKey.length === 0 || trimmedQuery.length === 0) {
+        return null;
+    }
+    const cacheKey = `keyword:${trimmedQuery}`;
+    const cached = geocodeCache.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;
+    geocodeCache.set(cacheKey, {
+        expiresAt: Date.now() + GEOCODE_CACHE_TTL_MS,
+        value,
+    });
+    return value;
+}
+export async function resolveLotteCinemaLocation(params, options = {}) {
+    const keyword = (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);
+    return {
+        keyword,
+        latitude: geocoded?.latitude ?? null,
+        longitude: geocoded?.longitude ?? null,
+        geocodeUsed: Boolean(geocoded),
+        formattedAddress: geocoded?.formattedAddress ?? null,
+    };
+}
+export async function fetchLotteCinemaNearbyTheaters(params, options = {}) {
+    const timeout = typeof params.timeout === 'number' ? params.timeout : DEFAULT_TIMEOUT_MS;
+    const limit = typeof params.limit === 'number' ? Math.max(1, params.limit) : 10;
+    const location = await resolveLotteCinemaLocation(params, options);
+    const { theaters } = await fetchLotteCinemaTicketingPage(timeout);
+    let nearby;
+    if (location.latitude !== null && location.longitude !== null) {
+        nearby = theaters
+            .filter((theater) => theater.latitude !== null && theater.longitude !== null)
+            .map((theater) => ({
+            ...theater,
+            distanceKm: Number(calculateDistanceKm(location.latitude, location.longitude, theater.latitude, theater.longitude).toFixed(2)),
+        }))
+            .sort((left, right) => left.distanceKm - right.distanceKm || left.theaterName.localeCompare(right.theaterName))
+            .slice(0, limit);
+    }
+    else {
+        const tokens = extractLocationTokens(location.keyword, location.formattedAddress);
+        nearby = theaters
+            .map((theater) => ({
+            theater,
+            score: scoreTheater(theater, tokens),
+        }))
+            .filter((item) => item.score > 0)
+            .sort((left, right) => right.score - left.score || left.theater.theaterName.localeCompare(right.theater.theaterName))
+            .slice(0, limit)
+            .map((item) => ({
+            ...item.theater,
+            distanceKm: null,
+        }));
+    }
+    return {
+        ...location,
+        playDate: params.playDate,
+        count: nearby.length,
+        theaters: nearby,
+    };
+}
+export async function resolveLotteCinemaNearestTheater(params, options = {}) {
+    const nearby = await fetchLotteCinemaNearbyTheaters({
+        ...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 __testOnlyClearLotteCinemaLocationCaches() {
+    geocodeCache.clear();
+}

package/dist/services/lottecinema/tools/findNearbyTheaters.js

@@ -0,0 +1,47 @@
+/**
+ * 롯데시네마 주변 지점 탐색 도구
+ */
+import * as z from 'zod';
+import { toYyyymmdd } from '../client.js';
+import { fetchLotteCinemaNearbyTheaters } from '../location.js';
+async function findNearbyTheaters(args, googleMapsApiKey) {
+    const { keyword, latitude, longitude, playDate = toYyyymmdd(), limit = 10, timeoutMs = 15000 } = args;
+    const hasCoordinates = typeof latitude === 'number' && typeof longitude === 'number';
+    const nearby = await fetchLotteCinemaNearbyTheaters({
+        keyword,
+        latitude: hasCoordinates ? latitude : keyword ? undefined : 37.5665,
+        longitude: hasCoordinates ? longitude : keyword ? undefined : 126.978,
+        playDate,
+        limit,
+        timeout: timeoutMs,
+    }, {
+        timeout: timeoutMs,
+        googleMapsApiKey: googleMapsApiKey || process.env.GOOGLE_MAPS_API_KEY,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(nearby, null, 2),
+            },
+        ],
+    };
+}
+export function createFindNearbyTheatersTool(googleMapsApiKey) {
+    return {
+        name: 'lottecinema_find_nearby_theaters',
+        metadata: {
+            title: '롯데시네마 주변 지점 탐색',
+            description: '위치 키워드 또는 좌표 기준으로 롯데시네마 지점을 거리순으로 조회합니다.',
+            inputSchema: {
+                keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 잠실역)'),
+                latitude: z.number().optional().default(37.5665).describe('위도 (기본값: 서울 시청 37.5665)'),
+                longitude: z.number().optional().default(126.978).describe('경도 (기본값: 서울 시청 126.978)'),
+                playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
+                limit: z.number().optional().default(10).describe('반환할 최대 지점 수 (기본값: 10)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: ((args) => findNearbyTheaters(args, googleMapsApiKey)),
+    };
+}

package/dist/services/lottecinema/tools/getRemainingSeats.js

@@ -0,0 +1,85 @@
+/**
+ * 롯데시네마 잔여 좌석 조회 도구
+ */
+import * as z from 'zod';
+import { fetchLotteCinemaNowShowing, toYyyymmdd } from '../client.js';
+import { resolveLotteCinemaNearestTheater } from '../location.js';
+async function getRemainingSeats(args, googleMapsApiKey) {
+    const { playDate = toYyyymmdd(), theaterId, movieId, keyword, latitude, longitude, limit = 50, timeoutMs = 15000, } = args;
+    let resolvedTheater = null;
+    let targetTheaterId = theaterId;
+    if (!targetTheaterId && (keyword || typeof latitude === 'number' || typeof longitude === 'number')) {
+        const resolved = await resolveLotteCinemaNearestTheater({
+            playDate,
+            keyword,
+            latitude,
+            longitude,
+            timeout: timeoutMs,
+        }, {
+            timeout: timeoutMs,
+            googleMapsApiKey: googleMapsApiKey || process.env.GOOGLE_MAPS_API_KEY,
+        });
+        resolvedTheater = resolved.theater;
+        targetTheaterId = resolved.theater?.theaterId;
+    }
+    const shouldReturnEmpty = !targetTheaterId && (keyword || typeof latitude === 'number' || typeof longitude === 'number');
+    const { showtimes } = shouldReturnEmpty
+        ? { showtimes: [] }
+        : await fetchLotteCinemaNowShowing({
+            playDate,
+            theaterId: targetTheaterId,
+            movieId,
+            timeout: timeoutMs,
+        });
+    const seats = showtimes
+        .filter((item) => (targetTheaterId ? item.theaterId === targetTheaterId : true))
+        .filter((item) => (movieId ? item.movieId === movieId : true))
+        .sort((a, b) => {
+        if (a.startTime === b.startTime) {
+            return a.theaterName.localeCompare(b.theaterName);
+        }
+        return a.startTime.localeCompare(b.startTime);
+    })
+        .slice(0, limit);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    playDate,
+                    filters: {
+                        theaterId: targetTheaterId || null,
+                        movieId: movieId || null,
+                        keyword: keyword || null,
+                        latitude: latitude ?? null,
+                        longitude: longitude ?? null,
+                        limit,
+                    },
+                    resolvedTheater,
+                    count: seats.length,
+                    seats,
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createGetRemainingSeatsTool(googleMapsApiKey) {
+    return {
+        name: 'lottecinema_get_remaining_seats',
+        metadata: {
+            title: '롯데시네마 잔여 좌석 조회',
+            description: '영화/지점/날짜 조건으로 롯데시네마 상영 회차별 남은 좌석 수를 조회합니다. 지점 ID가 없으면 위치 키워드 기준 최근접 극장을 선택할 수 있습니다.',
+            inputSchema: {
+                playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
+                theaterId: z.string().optional().describe('롯데시네마 지점 ID (예: 1016)'),
+                movieId: z.string().optional().describe('롯데시네마 대표 영화 코드 (예: 23816)'),
+                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) => getRemainingSeats(args, googleMapsApiKey)),
+    };
+}

package/dist/services/lottecinema/tools/listNowShowing.js

@@ -0,0 +1,79 @@
+/**
+ * 롯데시네마 영화 목록 조회 도구
+ */
+import * as z from 'zod';
+import { fetchLotteCinemaNowShowing, toYyyymmdd } from '../client.js';
+import { resolveLotteCinemaNearestTheater } from '../location.js';
+async function listNowShowing(args, googleMapsApiKey) {
+    const { playDate = toYyyymmdd(), theaterId, movieId, keyword, latitude, longitude, timeoutMs = 15000 } = args;
+    let resolvedTheater = null;
+    let targetTheaterId = theaterId;
+    if (!targetTheaterId && (keyword || typeof latitude === 'number' || typeof longitude === 'number')) {
+        const resolved = await resolveLotteCinemaNearestTheater({
+            playDate,
+            keyword,
+            latitude,
+            longitude,
+            timeout: timeoutMs,
+        }, {
+            timeout: timeoutMs,
+            googleMapsApiKey: googleMapsApiKey || process.env.GOOGLE_MAPS_API_KEY,
+        });
+        resolvedTheater = resolved.theater;
+        targetTheaterId = resolved.theater?.theaterId;
+    }
+    const shouldReturnEmpty = !targetTheaterId && (keyword || typeof latitude === 'number' || typeof longitude === 'number');
+    const { theaters, movies, showtimes } = shouldReturnEmpty
+        ? { theaters: [], movies: [], showtimes: [] }
+        : await fetchLotteCinemaNowShowing({
+            playDate,
+            theaterId: targetTheaterId,
+            movieId,
+            timeout: timeoutMs,
+        });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    playDate,
+                    filters: {
+                        theaterId: targetTheaterId || null,
+                        movieId: movieId || null,
+                        keyword: keyword || null,
+                        latitude: latitude ?? null,
+                        longitude: longitude ?? null,
+                    },
+                    resolvedTheater,
+                    counts: {
+                        theaters: theaters.length,
+                        movies: movies.length,
+                        showtimes: showtimes.length,
+                    },
+                    theaters,
+                    movies,
+                    showtimes,
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createListNowShowingTool(googleMapsApiKey) {
+    return {
+        name: 'lottecinema_list_now_showing',
+        metadata: {
+            title: '롯데시네마 영화 목록 조회',
+            description: '날짜/지점/영화 조건으로 롯데시네마 영화 및 상영 회차 목록을 조회합니다. 지점 ID가 없으면 위치 키워드 기준 최근접 극장을 선택할 수 있습니다.',
+            inputSchema: {
+                playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
+                theaterId: z.string().optional().describe('롯데시네마 지점 ID (예: 1016)'),
+                movieId: z.string().optional().describe('롯데시네마 대표 영화 코드 (예: 23816)'),
+                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) => listNowShowing(args, googleMapsApiKey)),
+    };
+}

package/dist/services/lottecinema/types.js

@@ -0,0 +1,4 @@
+/**
+ * 롯데시네마 서비스 전용 타입 정의
+ */
+export {};

package/dist/services/lottemart/api.js

@@ -0,0 +1,31 @@
+/**
+ * 롯데마트 모바일 도와센터 엔드포인트
+ */
+export const LOTTEMART_API = {
+    BASE_URL: 'https://company.lottemart.com',
+    ORIGIN_HOST: 'company.lottemart.com',
+    SOCKET_HOST: '210.93.146.57',
+    ORIGIN_REFERER: 'https://company.lottemart.com/mobiledowa/',
+    MARKET_OPTIONS_PATH: '/mobiledowa/inc/asp/search_market_list.asp',
+    STORE_SEARCH_PATH: '/mobiledowa/market/search_shop.asp',
+    PRODUCT_SEARCH_PATH: '/mobiledowa/product/search_product.asp',
+    PRODUCT_PAGE_PATH: '/mobiledowa/inc/asp/search_product_list.asp',
+};
+export const LOTTEMART_AREAS = [
+    '서울',
+    '경기',
+    '인천',
+    '강원',
+    '충북',
+    '충남',
+    '대전',
+    '경북',
+    '경남',
+    '대구',
+    '부산',
+    '울산',
+    '전북',
+    '전남',
+    '광주',
+    '기타',
+];