daiso 1.0.4 → 1.0.6

package/dist/cli/commands/daiso.js

@@ -0,0 +1,112 @@
+/**
+ * 다이소 관련 CLI 명령 핸들러
+ */
+import { printCommandHelp } from '../../cliHelp.js';
+import { parseCliArgs, toUrl, applyOptionsToQuery, toQueryOptions } from '../args.js';
+import { validateCommandOptions } from '../commandOptions.js';
+import { requestAndPrintResponse, requestAndPrintStoresWithKeywordFallback } from '../http.js';
+export async function handleGet(options, deps) {
+    const parsed = parseCliArgs(options);
+    if (parsed.options.help === 'true') {
+        return printCommandHelp('get', deps.writeOut, deps.writeErr);
+    }
+    const targetPath = parsed.positionals[0];
+    if (!targetPath) {
+        deps.writeErr('get 명령은 경로가 필요합니다. 예: daiso get /api/daiso/products --q 수납박스');
+        return 1;
+    }
+    const targetUrl = toUrl(targetPath);
+    applyOptionsToQuery(targetUrl, toQueryOptions(parsed.options));
+    return await requestAndPrintResponse(deps.fetchImpl, deps.writeOut, deps.writeErr, targetUrl, 'get', parsed.options.json === 'true');
+}
+export async function handleProducts(options, deps) {
+    const parsed = parseCliArgs(options);
+    if (parsed.options.help === 'true') {
+        return printCommandHelp('products', deps.writeOut, deps.writeErr);
+    }
+    if (validateCommandOptions('products', parsed.options, deps.writeErr)) {
+        return 1;
+    }
+    const query = parsed.positionals[0];
+    if (!query) {
+        deps.writeErr('products 명령은 검색어가 필요합니다. 예: daiso products 수납박스');
+        return 1;
+    }
+    const targetUrl = toUrl('/api/daiso/products');
+    targetUrl.searchParams.set('q', query);
+    applyOptionsToQuery(targetUrl, toQueryOptions(parsed.options));
+    return await requestAndPrintResponse(deps.fetchImpl, deps.writeOut, deps.writeErr, targetUrl, 'products', parsed.options.json === 'true');
+}
+export async function handleProduct(options, deps) {
+    const parsed = parseCliArgs(options);
+    if (parsed.options.help === 'true') {
+        return printCommandHelp('product', deps.writeOut, deps.writeErr);
+    }
+    if (validateCommandOptions('product', parsed.options, deps.writeErr)) {
+        return 1;
+    }
+    const productId = parsed.positionals[0];
+    if (!productId) {
+        deps.writeErr('product 명령은 제품 ID가 필요합니다. 예: daiso product 1034604');
+        return 1;
+    }
+    const targetUrl = toUrl(`/api/daiso/products/${productId}`);
+    applyOptionsToQuery(targetUrl, toQueryOptions(parsed.options));
+    return await requestAndPrintResponse(deps.fetchImpl, deps.writeOut, deps.writeErr, targetUrl, 'product', parsed.options.json === 'true');
+}
+export async function handleStores(options, deps) {
+    const parsed = parseCliArgs(options);
+    if (parsed.options.help === 'true') {
+        return printCommandHelp('stores', deps.writeOut, deps.writeErr);
+    }
+    const keyword = parsed.positionals[0];
+    if (keyword) {
+        parsed.options.keyword = keyword;
+    }
+    if (validateCommandOptions('stores', parsed.options, deps.writeErr)) {
+        return 1;
+    }
+    if (!parsed.options.keyword && !parsed.options.sido) {
+        deps.writeErr('stores 명령은 keyword 또는 --sido가 필요합니다. 예: daiso stores 강남역 / daiso stores --sido 서울');
+        return 1;
+    }
+    return await requestAndPrintStoresWithKeywordFallback(deps.fetchImpl, deps.writeOut, deps.writeErr, toQueryOptions(parsed.options), parsed.options.json === 'true');
+}
+export async function handleInventory(options, deps) {
+    const parsed = parseCliArgs(options);
+    if (parsed.options.help === 'true') {
+        return printCommandHelp('inventory', deps.writeOut, deps.writeErr);
+    }
+    if (validateCommandOptions('inventory', parsed.options, deps.writeErr)) {
+        return 1;
+    }
+    const productId = parsed.positionals[0];
+    if (!productId) {
+        deps.writeErr('inventory 명령은 제품 ID가 필요합니다. 제품명만 알면 먼저 daiso products 수납박스 명령으로 productId를 확인하세요. 예: daiso inventory 1034604 --keyword 강남역');
+        return 1;
+    }
+    const targetUrl = toUrl('/api/daiso/inventory');
+    targetUrl.searchParams.set('productId', productId);
+    applyOptionsToQuery(targetUrl, toQueryOptions(parsed.options));
+    return await requestAndPrintResponse(deps.fetchImpl, deps.writeOut, deps.writeErr, targetUrl, 'inventory', parsed.options.json === 'true');
+}
+export async function handleDisplayLocation(options, deps) {
+    const parsed = parseCliArgs(options);
+    if (parsed.options.help === 'true') {
+        return printCommandHelp('display-location', deps.writeOut, deps.writeErr);
+    }
+    if (validateCommandOptions('display-location', parsed.options, deps.writeErr)) {
+        return 1;
+    }
+    const productId = parsed.positionals[0];
+    const storeCode = parsed.positionals[1];
+    if (!productId || !storeCode) {
+        deps.writeErr('display-location 명령은 productId와 storeCode가 필요합니다. storeCode를 모르면 먼저 daiso inventory 1034604 --keyword 매장명 결과의 storeInventory.stores[].storeCode를 확인하세요. 예: daiso display-location 1034604 04515');
+        return 1;
+    }
+    const targetUrl = toUrl('/api/daiso/display-location');
+    targetUrl.searchParams.set('productId', productId);
+    targetUrl.searchParams.set('storeCode', storeCode);
+    applyOptionsToQuery(targetUrl, toQueryOptions(parsed.options));
+    return await requestAndPrintResponse(deps.fetchImpl, deps.writeOut, deps.writeErr, targetUrl, 'display-location', parsed.options.json === 'true');
+}

package/dist/cli/constants.js

@@ -0,0 +1,5 @@
+/**
+ * CLI 공통 상수
+ */
+export const DEFAULT_BASE_URL = 'https://mcp.aka.page';
+export const DEFAULT_MCP_URL = `${DEFAULT_BASE_URL}/mcp`;

package/dist/cli/deps.js

@@ -0,0 +1,48 @@
+/**
+ * CLI 기본 의존성 생성
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+import { runInteractiveCli } from '../cliInteractive.js';
+function loadVersion() {
+    const cliPath = fileURLToPath(import.meta.url);
+    const packagePath = path.resolve(path.dirname(cliPath), '../../package.json');
+    if (!existsSync(packagePath)) {
+        return '0.0.0';
+    }
+    const raw = readFileSync(packagePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return parsed.version ?? '0.0.0';
+}
+async function execCommand(command, args) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: 'inherit',
+            shell: false,
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code) => {
+            resolve(code ?? 1);
+        });
+    });
+}
+export function createDefaultDeps() {
+    return {
+        fetchImpl: fetch,
+        writeOut: (message) => {
+            process.stdout.write(`${message}\n`);
+        },
+        writeErr: (message) => {
+            process.stderr.write(`${message}\n`);
+        },
+        getVersion: loadVersion,
+        nowIso: () => new Date().toISOString(),
+        runCommand: execCommand,
+        isInteractiveTerminal: () => Boolean(process.stdin.isTTY && process.stdout.isTTY),
+        runInteractive: runInteractiveCli,
+    };
+}

package/dist/cli/http.js

@@ -0,0 +1,156 @@
+/**
+ * HTTP 요청 및 응답 처리 유틸리티
+ */
+import { renderApiEnvelope } from '../cliRenderer.js';
+import { buildDaisoStoreKeywordVariants } from '../utils/daisoKeyword.js';
+import { applyOptionsToQuery, toUrl } from './args.js';
+function parseErrorCode(bodyText) {
+    try {
+        const parsed = JSON.parse(bodyText);
+        return typeof parsed.error?.code === 'string' ? parsed.error.code : '';
+    }
+    catch {
+        return '';
+    }
+}
+function buildCliHint(command, url, bodyText) {
+    if (command !== 'get') {
+        return [];
+    }
+    const code = parseErrorCode(bodyText);
+    if (url.pathname === '/api/daiso/inventory' || code === 'MISSING_PRODUCT_ID') {
+        return [
+            '힌트: 제품명만 알면 먼저 daiso products <상품명> 명령으로 productId를 확인하세요.',
+            '다음 명령 예시: daiso inventory <productId> --keyword 강남역',
+        ];
+    }
+    if (url.pathname === '/api/daiso/products') {
+        return ['힌트: 제품 검색은 daiso products <상품명> 명령을 사용할 수 있습니다.'];
+    }
+    if (url.pathname === '/api/daiso/display-location' || code === 'MISSING_STORE_CODE') {
+        return [
+            '힌트: storeCode는 daiso inventory <productId> --keyword <매장명> 결과에서 확인하세요.',
+            '다음 명령 예시: daiso display-location <productId> <storeCode>',
+        ];
+    }
+    if (url.pathname === '/api/lottemart/products') {
+        return [
+            '힌트: 롯데마트 상품 조회는 매장 정보가 필요합니다.',
+            '다음 명령 예시: daiso lottemart-products <상품명> --storeName <매장명>',
+        ];
+    }
+    if (url.pathname === '/api/gs25/inventory') {
+        return [
+            '힌트: GS25 상품명만 알면 daiso gs25-inventory <상품명> --storeKeyword <매장명> 명령을 사용하세요.',
+            'itemCode만 알면 daiso gs25-inventory <itemCode> 형식 대신 daiso get /api/gs25/inventory --itemCode <itemCode> --storeKeyword <매장명> 을 사용하세요.',
+        ];
+    }
+    if (url.pathname === '/api/emart24/inventory') {
+        return [
+            '힌트: 이마트24 상품명만 알면 daiso emart24-products <상품명> 명령으로 pluCd를 확인하세요.',
+            '다음 명령 예시: daiso emart24-inventory <pluCd> --storeKeyword 강남',
+        ];
+    }
+    if (url.pathname === '/api/seveneleven/inventory') {
+        return [
+            '힌트: 세븐일레븐 재고는 매장 키워드가 필요합니다.',
+            '다음 명령 예시: daiso get /api/seveneleven/inventory --keyword <상품명> --storeKeyword 강남',
+        ];
+    }
+    return [];
+}
+export async function requestAndPrintResponse(fetchImpl, writeOut, writeErr, url, command, asJson) {
+    try {
+        const response = await fetchImpl(url.toString());
+        if (!response.ok) {
+            const bodyText = await response.text();
+            writeErr(`요청 실패: HTTP ${response.status}`);
+            if (bodyText) {
+                writeErr(bodyText);
+                for (const hint of buildCliHint(command, url, bodyText)) {
+                    writeErr(hint);
+                }
+            }
+            return 1;
+        }
+        const payload = (await response.json());
+        if (asJson) {
+            writeOut(JSON.stringify(payload, null, 2));
+        }
+        else {
+            writeOut(renderApiEnvelope(command, url, payload));
+        }
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        writeErr(`요청 중 오류 발생: ${message}`);
+        return 1;
+    }
+}
+function toStoreCount(payload) {
+    if (typeof payload !== 'object' || payload === null) {
+        return 0;
+    }
+    const record = payload;
+    if (record.success !== true || typeof record.data !== 'object' || record.data === null) {
+        return 0;
+    }
+    const stores = record.data.stores;
+    return Array.isArray(stores) ? stores.length : 0;
+}
+export async function requestAndPrintStoresWithKeywordFallback(fetchImpl, writeOut, writeErr, options, asJson) {
+    const originalKeyword = options.keyword;
+    if (!originalKeyword) {
+        const url = toUrl('/api/daiso/stores');
+        applyOptionsToQuery(url, options);
+        return await requestAndPrintResponse(fetchImpl, writeOut, writeErr, url, 'stores', asJson);
+    }
+    const keywords = buildDaisoStoreKeywordVariants(originalKeyword);
+    const candidates = keywords.length > 0 ? keywords : [originalKeyword];
+    try {
+        let lastUrl = toUrl('/api/daiso/stores');
+        let lastPayload = null;
+        for (const keyword of candidates) {
+            const targetUrl = toUrl('/api/daiso/stores');
+            applyOptionsToQuery(targetUrl, { ...options, keyword });
+            lastUrl = targetUrl;
+            const response = await fetchImpl(targetUrl.toString());
+            if (!response.ok) {
+                const bodyText = await response.text();
+                writeErr(`요청 실패: HTTP ${response.status}`);
+                if (bodyText) {
+                    writeErr(bodyText);
+                }
+                return 1;
+            }
+            const payload = (await response.json());
+            lastPayload = payload;
+            if (toStoreCount(payload) > 0) {
+                if (keyword !== originalKeyword) {
+                    writeOut(`입력 키워드 "${originalKeyword}" 대신 "${keyword}"로 매장을 찾았습니다.`);
+                }
+                if (asJson) {
+                    writeOut(JSON.stringify(payload, null, 2));
+                }
+                else {
+                    writeOut(renderApiEnvelope('stores', targetUrl, payload));
+                }
+                return 0;
+            }
+        }
+        if (asJson) {
+            writeOut(JSON.stringify(lastPayload, null, 2));
+        }
+        else {
+            writeOut(renderApiEnvelope('stores', lastUrl, lastPayload));
+        }
+        writeOut('힌트: "안산 중앙역" 대신 "안산중앙" 또는 "고잔"으로 검색해보세요.');
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        writeErr(`요청 중 오류 발생: ${message}`);
+        return 1;
+    }
+}

package/dist/cli/interactiveFetch.js

@@ -0,0 +1,31 @@
+/**
+ * 인터랙티브 CLI API 호출 헬퍼
+ */
+import { buildDaisoStoreKeywordVariants, parseStores } from '../utils/cliInteractiveHelpers.js';
+const BASE_URL = 'https://mcp.aka.page';
+export async function fetchEnvelope(fetchImpl, path, query = {}) {
+    const url = new URL(path, BASE_URL);
+    for (const [key, value] of Object.entries(query)) {
+        url.searchParams.set(key, value);
+    }
+    const response = await fetchImpl(url.toString());
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status} (${url.pathname})`);
+    }
+    return (await response.json());
+}
+export async function fetchStoresWithKeywordFallback(fetchImpl, service, keyword) {
+    const candidates = service === 'daiso' ? buildDaisoStoreKeywordVariants(keyword) : [keyword];
+    const keywords = candidates.length > 0 ? candidates : [keyword];
+    for (const currentKeyword of keywords) {
+        const payload = await fetchEnvelope(fetchImpl, `/api/${service}/stores`, {
+            keyword: currentKeyword,
+            limit: '10',
+        });
+        const stores = parseStores(payload);
+        if (stores.length > 0) {
+            return { stores, matchedKeyword: currentKeyword };
+        }
+    }
+    return { stores: [], matchedKeyword: keyword };
+}

package/dist/cli/interactiveItemSearch.js

@@ -0,0 +1,261 @@
+/**
+ * 인터랙티브 CLI 상품/극장 조회 절차
+ */
+import { pickFromList } from '../cliPicker.js';
+import { isRecord, parseDaisoProducts, toText } from '../utils/cliInteractiveHelpers.js';
+import { askNonEmpty } from './interactivePrompt.js';
+import { fetchEnvelope } from './interactiveFetch.js';
+export function parseLotteCinemaTheaters(payload) {
+    if (!isRecord(payload) || payload.success !== true || !isRecord(payload.data)) {
+        return [];
+    }
+    const theaters = payload.data.theaters;
+    if (!Array.isArray(theaters)) {
+        return [];
+    }
+    return theaters
+        .filter((entry) => isRecord(entry))
+        .map((entry) => ({
+        theaterId: toText(entry.theaterId),
+        name: toText(entry.theaterName),
+        address: toText(entry.address),
+        distanceKm: toText(entry.distanceKm),
+    }))
+        .filter((entry) => entry.theaterId.length > 0 && entry.name.length > 0);
+}
+export function printTheaterDetail(writeOut, theater) {
+    writeOut('');
+    writeOut('[선택한 극장 정보]');
+    writeOut(`- 극장명: ${theater.name}`);
+    writeOut(`- 극장 ID: ${theater.theaterId}`);
+    writeOut(`- 주소: ${theater.address || '정보 없음'}`);
+    writeOut(`- 거리: ${theater.distanceKm ? `${theater.distanceKm}km` : '정보 없음'}`);
+    writeOut('');
+}
+export async function runLotteCinemaSearch(deps, prompt, theater) {
+    const playDate = await askNonEmpty(prompt, '조회 날짜를 입력하세요 (YYYYMMDD): ');
+    const payload = await fetchEnvelope(deps.fetchImpl, '/api/lottecinema/movies', {
+        playDate,
+        theaterId: theater.theaterId,
+    });
+    if (!isRecord(payload) || payload.success !== true || !isRecord(payload.data)) {
+        deps.writeOut('롯데시네마 응답을 해석하지 못했습니다.');
+        return;
+    }
+    const moviesRaw = payload.data.movies;
+    const showtimesRaw = payload.data.showtimes;
+    const movies = Array.isArray(moviesRaw)
+        ? moviesRaw
+            .filter((entry) => isRecord(entry))
+            .map((entry) => ({
+            movieId: toText(entry.movieId),
+            movieName: toText(entry.movieName),
+        }))
+            .filter((entry) => entry.movieId.length > 0 && entry.movieName.length > 0)
+        : [];
+    const seats = Array.isArray(showtimesRaw)
+        ? showtimesRaw
+            .filter((entry) => isRecord(entry))
+            .map((entry) => ({
+            movieName: toText(entry.movieName),
+            screenName: toText(entry.screenName),
+            startTime: toText(entry.startTime),
+            remainingSeats: toText(entry.remainingSeats),
+            totalSeats: toText(entry.totalSeats),
+        }))
+            .filter((entry) => entry.movieName.length > 0)
+        : [];
+    deps.writeOut('');
+    deps.writeOut('[롯데시네마 상영 결과]');
+    deps.writeOut(`- 극장: ${theater.name}`);
+    deps.writeOut(`- 날짜: ${playDate}`);
+    deps.writeOut(`- 상영 영화 수: ${movies.length}`);
+    if (movies.length === 0) {
+        deps.writeOut('- 상영 중인 영화가 없습니다.');
+    }
+    else {
+        for (const movie of movies.slice(0, 10)) {
+            deps.writeOut(`- 영화: ${movie.movieName} (${movie.movieId})`);
+        }
+        if (movies.length > 10) {
+            deps.writeOut(`- 영화: ...외 ${movies.length - 10}편`);
+        }
+    }
+    if (seats.length === 0) {
+        deps.writeOut('- 회차/좌석 정보가 없습니다.');
+        return;
+    }
+    deps.writeOut('- 회차/좌석:');
+    for (const seat of seats.slice(0, 15)) {
+        deps.writeOut(`  ${seat.startTime} | ${seat.movieName} | ${seat.screenName || '상영관 정보 없음'} | ${seat.remainingSeats}/${seat.totalSeats}`);
+    }
+    if (seats.length > 15) {
+        deps.writeOut(`  ...외 ${seats.length - 15}건`);
+    }
+}
+export async function runDaisoItemSearch(deps, prompt, store, initialKeyword) {
+    const keyword = initialKeyword && initialKeyword.trim().length > 0
+        ? initialKeyword.trim()
+        : await askNonEmpty(prompt, '찾을 상품 키워드를 입력하세요: ');
+    const productsPayload = await fetchEnvelope(deps.fetchImpl, '/api/daiso/products', {
+        q: keyword,
+        pageSize: '10',
+    });
+    const products = parseDaisoProducts(productsPayload);
+    if (products.length === 0) {
+        deps.writeOut('검색된 다이소 상품이 없습니다.');
+        return;
+    }
+    const selectedProduct = await pickFromList({
+        prompt,
+        writeOut: deps.writeOut,
+        title: '[상품 선택]',
+        emptyText: '검색된 다이소 상품이 없습니다.',
+        cancelText: '상품 선택을 취소했습니다.',
+        items: products,
+        renderItem: (product, index) => `${index + 1}. ${product.name} (${product.price}원, ID: ${product.id})`,
+        filterText: (product) => `${product.name} ${product.id}`,
+        indexText: '입력: 번호 선택 | /키워드 필터 | all 전체보기 | 0 취소',
+    });
+    if (!selectedProduct) {
+        return;
+    }
+    const inventoryPayload = await fetchEnvelope(deps.fetchImpl, '/api/daiso/inventory', {
+        productId: selectedProduct.id,
+        keyword: store.name,
+        pageSize: '50',
+    });
+    if (!isRecord(inventoryPayload) || inventoryPayload.success !== true || !isRecord(inventoryPayload.data)) {
+        deps.writeOut('재고 응답을 해석하지 못했습니다.');
+        return;
+    }
+    const storeInventory = inventoryPayload.data.storeInventory;
+    if (!isRecord(storeInventory) || !Array.isArray(storeInventory.stores)) {
+        deps.writeOut('매장 재고 데이터가 없습니다.');
+        return;
+    }
+    const match = storeInventory.stores.find((entry) => {
+        if (!isRecord(entry)) {
+            return false;
+        }
+        const storeName = toText(entry.storeName);
+        return storeName === store.name || storeName.includes(store.name);
+    });
+    deps.writeOut('');
+    deps.writeOut('[재고 결과]');
+    deps.writeOut(`- 상품: ${selectedProduct.name}`);
+    deps.writeOut(`- 매장: ${store.name}`);
+    if (isRecord(match)) {
+        const quantity = toText(match.quantity) || '0';
+        deps.writeOut(`- 재고 수량: ${quantity}`);
+        return;
+    }
+    deps.writeOut('- 선택 매장에 대한 재고 정보를 찾지 못했습니다.');
+}
+export async function runOliveyoungItemSearch(deps, prompt, store) {
+    const keyword = await askNonEmpty(prompt, '찾을 상품 키워드를 입력하세요: ');
+    const payload = await fetchEnvelope(deps.fetchImpl, '/api/oliveyoung/inventory', {
+        keyword,
+        storeKeyword: store.name,
+        size: '10',
+    });
+    if (!isRecord(payload) || payload.success !== true || !isRecord(payload.data)) {
+        deps.writeOut('재고 응답을 해석하지 못했습니다.');
+        return;
+    }
+    const inventory = payload.data.inventory;
+    if (!isRecord(inventory) || !Array.isArray(inventory.products)) {
+        deps.writeOut('올리브영 상품 데이터가 없습니다.');
+        return;
+    }
+    const products = inventory.products
+        .filter((entry) => isRecord(entry))
+        .map((entry) => ({
+        goodsNumber: toText(entry.goodsNumber),
+        goodsName: toText(entry.goodsName),
+        priceToPay: Number.parseInt(toText(entry.priceToPay), 10) || 0,
+        o2oRemainQuantity: Number.parseInt(toText(entry.o2oRemainQuantity), 10) || 0,
+    }))
+        .filter((entry) => entry.goodsName.length > 0);
+    deps.writeOut('');
+    deps.writeOut('[재고 결과]');
+    deps.writeOut(`- 매장: ${store.name}`);
+    deps.writeOut(`- 검색어: ${keyword}`);
+    if (products.length === 0) {
+        deps.writeOut('- 검색된 상품이 없습니다.');
+        return;
+    }
+    const selected = await pickFromList({
+        prompt,
+        writeOut: deps.writeOut,
+        title: '[상품 선택]',
+        emptyText: '검색된 상품이 없습니다.',
+        cancelText: '상품 선택을 취소했습니다.',
+        items: products,
+        renderItem: (product, index) => `${index + 1}. ${product.goodsName} (${product.priceToPay}원, 남은수량 ${product.o2oRemainQuantity})`,
+        filterText: (product) => `${product.goodsName} ${product.goodsNumber}`,
+        indexText: '입력: 번호 선택 | /키워드 필터 | all 전체보기 | 0 취소',
+    });
+    if (!selected) {
+        return;
+    }
+    deps.writeOut(`- 상품: ${selected.goodsName}`);
+    deps.writeOut(`- 가격: ${selected.priceToPay}원`);
+    deps.writeOut(`- 남은수량: ${selected.o2oRemainQuantity}`);
+}
+export async function runCuItemSearch(deps, prompt, store) {
+    const keyword = await askNonEmpty(prompt, '찾을 상품 키워드를 입력하세요: ');
+    const payload = await fetchEnvelope(deps.fetchImpl, '/api/cu/inventory', {
+        keyword,
+        storeKeyword: store.name,
+        size: '10',
+        storeLimit: '10',
+    });
+    if (!isRecord(payload) || payload.success !== true || !isRecord(payload.data)) {
+        deps.writeOut('재고 응답을 해석하지 못했습니다.');
+        return;
+    }
+    const inventory = payload.data.inventory;
+    if (!isRecord(inventory) || !Array.isArray(inventory.items)) {
+        deps.writeOut('CU 상품 데이터가 없습니다.');
+        return;
+    }
+    const items = inventory.items
+        .filter((entry) => isRecord(entry))
+        .map((entry) => ({
+        itemCode: toText(entry.itemCode),
+        itemName: toText(entry.itemName),
+        price: Number.parseInt(toText(entry.price), 10) || 0,
+        pickupYn: toText(entry.pickupYn).toLowerCase() === 'true',
+        deliveryYn: toText(entry.deliveryYn).toLowerCase() === 'true',
+        reserveYn: toText(entry.reserveYn).toLowerCase() === 'true',
+    }))
+        .filter((entry) => entry.itemName.length > 0);
+    deps.writeOut('');
+    deps.writeOut('[재고 결과]');
+    deps.writeOut(`- 매장: ${store.name}`);
+    deps.writeOut(`- 검색어: ${keyword}`);
+    if (items.length === 0) {
+        deps.writeOut('- 검색된 상품이 없습니다.');
+        return;
+    }
+    const selected = await pickFromList({
+        prompt,
+        writeOut: deps.writeOut,
+        title: '[상품 선택]',
+        emptyText: '검색된 상품이 없습니다.',
+        cancelText: '상품 선택을 취소했습니다.',
+        items,
+        renderItem: (item, index) => `${index + 1}. ${item.itemName} (${item.price}원)`,
+        filterText: (item) => `${item.itemName} ${item.itemCode}`,
+        indexText: '입력: 번호 선택 | /키워드 필터 | all 전체보기 | 0 취소',
+    });
+    if (!selected) {
+        return;
+    }
+    deps.writeOut(`- 상품: ${selected.itemName}`);
+    deps.writeOut(`- 가격: ${selected.price}원`);
+    deps.writeOut(`- 픽업 가능: ${selected.pickupYn ? '예' : '아니오'}`);
+    deps.writeOut(`- 배달 가능: ${selected.deliveryYn ? '예' : '아니오'}`);
+    deps.writeOut(`- 예약 가능: ${selected.reserveYn ? '예' : '아니오'}`);
+}

package/dist/cli/interactivePrompt.js

@@ -0,0 +1,50 @@
+/**
+ * 인터랙티브 CLI 입력/출력 헬퍼
+ */
+export async function askMenu(prompt, title, options, writeOut) {
+    while (true) {
+        const answer = await prompt.ask(`${title} `);
+        const picked = Number.parseInt(answer, 10);
+        if (Number.isNaN(picked) || picked < 0 || picked > options.length) {
+            writeOut?.(`번호로 입력하세요. 0부터 ${options.length} 사이에서 선택할 수 있습니다.`);
+            continue;
+        }
+        return picked;
+    }
+}
+export async function askYesNo(prompt, question) {
+    while (true) {
+        const answer = (await prompt.ask(question)).toLowerCase();
+        if (answer === 'y' || answer === 'yes') {
+            return true;
+        }
+        if (answer === 'n' || answer === 'no') {
+            return false;
+        }
+    }
+}
+export async function askNonEmpty(prompt, question) {
+    while (true) {
+        const answer = await prompt.ask(question);
+        if (answer.length > 0) {
+            return answer;
+        }
+    }
+}
+export async function askNextAction(prompt, writeOut) {
+    writeOut('');
+    writeOut('[다음 동작]');
+    writeOut('1. 같은 매장에서 다른 상품 찾기');
+    writeOut('2. 다른 매장/서비스 다시 선택하기');
+    writeOut('3. 종료하기');
+    const choice = await askMenu(prompt, '번호를 선택하세요:', ['same-store', 'change-store', 'exit'], writeOut);
+    return choice === 1 ? 'same-store' : choice === 2 ? 'change-store' : 'exit';
+}
+export function printStoreDetail(writeOut, store) {
+    writeOut('');
+    writeOut('[선택한 매장 정보]');
+    writeOut(`- 매장명: ${store.name}`);
+    writeOut(`- 주소: ${store.address || '정보 없음'}`);
+    writeOut(`- 전화: ${store.phone || '정보 없음'}`);
+    writeOut('');
+}

package/dist/cli/interactiveTypes.js

@@ -0,0 +1,4 @@
+/**
+ * 인터랙티브 CLI 공용 타입
+ */
+export {};

package/dist/cli/types.js

@@ -0,0 +1,4 @@
+/**
+ * CLI 공통 타입 정의
+ */
+export {};