@isnow890/naver-search-mcp 1.0.19 → 1.0.20

package/dist/src/index.js

@@ -1,109 +1,72 @@
-#!/usr/bin/env node
-import * as dotenv from "dotenv";
-import pkg from "../package.json" with { type: "json" };
-console.error("[MCP] dotenv import 완료");
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
 import { NaverSearchClient } from "./clients/naver-search.client.js";
-import { unifiedSearchTools } from "./tools/unified-search.tools.js";
-import { unifiedSearchToolHandlers } from "./handlers/unified-search.handlers.js";
-dotenv.config();
-console.error("[MCP] dotenv.config() 실행됨");
-// 환경 변수 유효성 검사
-const NAVER_CLIENT_ID = process.env.NAVER_CLIENT_ID;
-const NAVER_CLIENT_SECRET = process.env.NAVER_CLIENT_SECRET;
-console.error("[MCP] 환경변수 읽음", { NAVER_CLIENT_ID, NAVER_CLIENT_SECRET });
-if (!NAVER_CLIENT_ID || !NAVER_CLIENT_SECRET) {
-    console.error("[MCP] Error: NAVER_CLIENT_ID and NAVER_CLIENT_SECRET environment variables are required");
-    process.exit(1);
-}
-// 네이버 검색 클라이언트 초기화
-const client = NaverSearchClient.getInstance();
-client.initialize({
-    clientId: NAVER_CLIENT_ID,
-    clientSecret: NAVER_CLIENT_SECRET,
-});
-console.error("[MCP] NaverSearchClient 초기화 완료");
-// MCP 서버 인스턴스 생성
-const server = new Server({
-    name: "naver-search",
-    version: pkg.version,
-}, {
-    capabilities: {
-        tools: {},
-    },
-});
-console.error("[MCP] Server 인스턴스 생성 완료");
-// 도구 목록을 반환하는 핸들러 등록
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    console.error("[MCP] ListToolsRequestSchema 핸들러 호출됨");
-    return {
-        tools: [
-            //...searchTools,
-            // //  ...datalabTools, 
-            ...unifiedSearchTools
-        ],
-    };
+import { searchTools } from "./tools/search.tools.js";
+import { datalabTools } from "./tools/datalab.tools.js";
+import { searchToolHandlers } from "./handlers/search.handlers.js";
+import { datalabToolHandlers } from "./handlers/datalab.handlers.js";
+// Configuration schema for Smithery
+export const configSchema = z.object({
+    NAVER_CLIENT_ID: z.string().describe("Naver API Client ID"),
+    NAVER_CLIENT_SECRET: z.string().describe("Naver API Client Secret")
 });
-const toolHandlers = {
-    // ...searchToolHandlers,
-    // ...datalabToolHandlers,
-    ...unifiedSearchToolHandlers,
-};
-// 에러 응답 헬퍼 함수
-function createErrorResponse(error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error("[MCP] API Error:", errorMessage);
-    return {
-        content: [{ type: "text", text: `Error: ${errorMessage}` }],
-        isError: true,
+export default function ({ config }) {
+    // Create a new MCP server per MCP spec
+    const server = new McpServer({
+        name: "naver-search",
+        version: "1.0.18",
+    });
+    // Initialize Naver client with config
+    const client = NaverSearchClient.getInstance();
+    client.initialize({
+        clientId: config.NAVER_CLIENT_ID,
+        clientSecret: config.NAVER_CLIENT_SECRET,
+    });
+    const toolHandlers = {
+        ...searchToolHandlers,
+        ...datalabToolHandlers,
     };
-}
-// 도구 실행 요청 핸들러 등록
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    try {
-        const { name, arguments: args } = request.params;
-        console.error(`[MCP] Executing tool: ${name} with args:`, args);
-        if (!args) {
-            throw new Error("Arguments are required");
-        }
-        const handler = toolHandlers[name];
-        if (!handler)
-            throw new Error(`Unknown tool: ${name}`);
-        const result = await handler(args);
-        console.error(`[MCP] Tool ${name} executed successfully`);
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        };
-    }
-    catch (error) {
-        return createErrorResponse(error);
-    }
-});
-// 서버 시작 함수
-async function runServer() {
-    try {
-        console.error("[MCP] runServer 진입");
-        const transport = new StdioServerTransport();
-        // 서버 에러 핸들링
-        process.on("uncaughtException", (error) => {
-            console.error("[MCP] Uncaught Exception:", error);
+    // Add all search tools
+    searchTools.forEach(tool => {
+        server.tool(tool.name, tool.description, tool.inputSchema, async (args) => {
+            try {
+                const handler = toolHandlers[tool.name];
+                if (!handler)
+                    throw new Error(`Unknown tool: ${tool.name}`);
+                const result = await handler(args);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                    isError: true,
+                };
+            }
         });
-        process.on("unhandledRejection", (reason, promise) => {
-            console.error("[MCP] Unhandled Rejection at:", promise, "reason:", reason);
+    });
+    // Add all datalab tools
+    datalabTools.forEach(tool => {
+        server.tool(tool.name, tool.description, tool.inputSchema, async (args) => {
+            try {
+                const handler = toolHandlers[tool.name];
+                if (!handler)
+                    throw new Error(`Unknown tool: ${tool.name}`);
+                const result = await handler(args);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                    isError: true,
+                };
+            }
         });
-        await server.connect(transport);
-        console.error("[MCP] Naver Search MCP Server running on stdio");
-    }
-    catch (error) {
-        console.error("[MCP] Fatal error running server:", error);
-        process.exit(1);
-    }
+    });
+    return server.server;
 }
-// 서버 시작
-console.error("[MCP] runServer 호출 직전");
-runServer().catch((error) => {
-    console.error("[MCP] Fatal error running server (catch):", error);
-    process.exit(1);
-});

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@isnow890/naver-search-mcp",
-  "version": "1.0.19",
+  "version": "1.0.20",
   "description": "Naver Search MCP Server",
   "main": "dist/index.js",
+  "module": "./src/index.ts",
   "types": "dist/index.d.ts",
   "files": [
     "dist"
@@ -12,8 +13,7 @@
     "build": "tsc",
     "prepare": "npm run build",
     "watch": "tsc --watch",
-    "start": "node dist/src/index.js",
-    "test": "npx cross-env NODE_OPTIONS=--experimental-vm-modules npx jest"
+    "start": "node dist/src/index.js"
   },
   "engines": {
     "node": ">=18"
@@ -21,17 +21,14 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.10.2",
     "axios": "^1.6.7",
-    "dotenv": "^16.4.5",
-    "sharp": "^0.33.2",
     "zod": "^3.22.4",
-    "zod-to-json-schema": "^3.23.5"
+    "zod-to-json-schema": "^3.23.5",
+    "sharp": "^0.33.2",
+    "dotenv": "^16.4.5"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.14",
     "@types/node": "^22",
-    "jest": "^29.7.0",
     "shx": "^0.3.4",
-    "ts-jest": "^29.3.2",
     "typescript": "^5.3.3"
   },
   "author": "isnow890",

package/dist/package.json

@@ -1,43 +0,0 @@
-{
-    "name": "@isnow890/naver-search-mcp",
-    "version": "1.0.19",
-    "description": "Naver Search MCP Server",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "files": [
-        "dist"
-    ],
-    "scripts": {
-        "prebuild": "shx rm -rf dist",
-        "build": "tsc",
-        "prepare": "npm run build",
-        "watch": "tsc --watch",
-        "start": "node dist/src/index.js",
-        "test": "npx cross-env NODE_OPTIONS=--experimental-vm-modules npx jest"
-    },
-    "engines": {
-        "node": ">=18"
-    },
-    "dependencies": {
-        "@modelcontextprotocol/sdk": "1.10.2",
-        "axios": "^1.6.7",
-        "dotenv": "^16.4.5",
-        "sharp": "^0.33.2",
-        "zod": "^3.22.4",
-        "zod-to-json-schema": "^3.23.5"
-    },
-    "devDependencies": {
-        "@types/jest": "^29.5.14",
-        "@types/node": "^22",
-        "jest": "^29.7.0",
-        "shx": "^0.3.4",
-        "ts-jest": "^29.3.2",
-        "typescript": "^5.3.3"
-    },
-    "author": "isnow890",
-    "license": "MIT",
-    "bin": {
-        "naver-search-mcp": "dist/src/index.js"
-    },
-    "type": "module"
-}

package/dist/src/handlers/unified-search.handlers.js

@@ -1,144 +0,0 @@
-import { searchToolHandlers } from "./search.handlers.js";
-import { datalabToolHandlers } from "./datalab.handlers.js";
-import { UnifiedSearchSchema } from "../schemas/unified-search.schemas.js";
-/**
- * 통합 검색 핸들러
- * 일반 검색과 트렌드 검색을 통합하여 처리
- * @param args 통합 검색 파라미터
- * @returns 검색 결과
- */
-export async function handleUnifiedSearch(args) {
-    // Zod를 사용하여 입력 파라미터 검증
-    const parsedArgs = UnifiedSearchSchema.parse(args);
-    // 검색 유형에 따라 처리
-    if (parsedArgs.searchType === "general") {
-        return handleGeneralSearch(parsedArgs);
-    }
-    else if (parsedArgs.searchType === "trend") {
-        return handleTrendSearch(parsedArgs);
-    }
-    throw new Error("지원하지 않는 검색 유형입니다.");
-}
-/**
- * 일반 검색 핸들러
- * @param search 일반 검색 파라미터
- * @returns 검색 결과
- */
-async function handleGeneralSearch(search) {
-    const { generalType, params } = search;
-    // 모든 검색 타입을 통합하여 검색하는 경우
-    if (generalType === "all") {
-        return handleAllGeneralSearch(params);
-    }
-    // 단일 검색 유형인 경우
-    const handlerKey = `search_${generalType}`;
-    const handler = searchToolHandlers[handlerKey];
-    if (!handler) {
-        throw new Error(`'${generalType}' 유형에 대한 검색 핸들러가 없습니다.`);
-    }
-    return handler(params);
-}
-/**
- * 모든 일반 검색을 병렬로 수행하는 핸들러
- * @param params 검색 파라미터
- * @returns 모든 검색 결과 (검색 유형별로 객체 키 할당)
- */
-async function handleAllGeneralSearch(params) {
-    // 모든 가능한 일반 검색 타입 (local과 다른 타입은 파라미터가 다르므로 주의)
-    // 검색할 타입 목록 (local은 파라미터가 다르므로 처리 방식 구분)
-    const generalTypes = [
-        "webkr", "news", "blog", "shop", "image",
-        "kin", "book", "encyc", "academic", "cafearticle"
-    ];
-    // Promise 배열 생성 및 결과 수집
-    const searchPromises = generalTypes.map(type => {
-        const handlerKey = `search_${type}`;
-        const handler = searchToolHandlers[handlerKey];
-        return handler(params)
-            .then(result => ({ type, result }))
-            .catch(error => ({ type, error: error.message }));
-    });
-    // local 검색은 파라미터가 다르지만 동일 인터페이스로 처리
-    const localHandler = searchToolHandlers["search_local"];
-    searchPromises.push(localHandler(params)
-        .then(result => ({ type: "local", result }))
-        .catch(error => ({ type: "local", error: error.message })));
-    // 모든 검색 병렬 실행
-    const results = await Promise.all(searchPromises);
-    // 결과를 유형별로 객체로 변환
-    return results.reduce((acc, item) => {
-        const { type } = item;
-        if ('result' in item) {
-            acc[type] = item.result;
-        }
-        else if ('error' in item) {
-            acc[type] = { error: item.error };
-        }
-        return acc;
-    }, {});
-}
-/**
- * 트렌드 검색 핸들러
- * @param search 트렌드 검색 파라미터
- * @returns 검색 결과
- */
-async function handleTrendSearch(search) {
-    const { trendType, params } = search;
-    // 모든 트렌드 타입을 통합하여 검색하는 경우
-    if (trendType === "all") {
-        return handleAllTrendSearch(params);
-    }
-    // 단일 트렌드 검색 유형인 경우
-    const handlerKey = `datalab_${trendType}`;
-    const handler = datalabToolHandlers[handlerKey];
-    if (!handler) {
-        throw new Error(`'${trendType}' 유형에 대한 트렌드 검색 핸들러가 없습니다.`);
-    }
-    return handler(params);
-}
-/**
- * 모든 트렌드 검색을 병렬로 수행하는 핸들러
- * @param params 트렌드 검색 파라미터
- * @returns 모든 트렌드 검색 결과 (검색 유형별로 객체 키 할당)
- */
-async function handleAllTrendSearch(params) {
-    // 파라미터 유형에 따라 가능한 트렌드 검색 타입 결정
-    const trendTypes = [
-        "search"
-    ];
-    // 쇼핑 관련 트렌드는 category 파라미터가 있어야 함
-    if (params.category) {
-        trendTypes.push("shopping_category", "shopping_by_device", "shopping_by_gender", "shopping_by_age", "shopping_keywords");
-        // 키워드 관련 트렌드는 keyword 파라미터가 있어야 함
-        if (params.keyword) {
-            trendTypes.push("shopping_keyword_by_device", "shopping_keyword_by_gender", "shopping_keyword_by_age");
-        }
-    }
-    // Promise 배열 생성 및 결과 수집
-    const trendPromises = trendTypes.map(type => {
-        const handlerKey = `datalab_${type}`;
-        const handler = datalabToolHandlers[handlerKey];
-        // 일부 트렌드 검색은 파라미터 형식이 다를 수 있으므로 
-        // 에러가 발생해도 다른 검색은 계속 진행하도록 처리
-        return handler(params)
-            .then((result) => ({ type, result }))
-            .catch((error) => ({ type, error: error.message }));
-    });
-    // 모든 트렌드 검색 병렬 실행
-    const results = await Promise.all(trendPromises);
-    // 결과를 유형별로 객체로 변환
-    return results.reduce((acc, item) => {
-        const { type } = item;
-        if ('result' in item) {
-            acc[type] = item.result;
-        }
-        else if ('error' in item) {
-            acc[type] = { error: item.error };
-        }
-        return acc;
-    }, {});
-}
-// 통합 검색 도구 핸들러 맵
-export const unifiedSearchToolHandlers = {
-    unified_search: (args) => handleUnifiedSearch(args)
-};

package/dist/src/schemas/unified-search.schemas.js

@@ -1,70 +0,0 @@
-import { z } from "zod";
-import { SearchArgsSchema, NaverLocalSearchParamsSchema } from "./search.schemas.js";
-import { DatalabSearchSchema, DatalabShoppingSchema, DatalabShoppingDeviceSchema, DatalabShoppingGenderSchema, DatalabShoppingAgeSchema, DatalabShoppingKeywordsSchema, DatalabShoppingKeywordDeviceSchema, DatalabShoppingKeywordGenderSchema, DatalabShoppingKeywordAgeSchema } from "./datalab.schemas.js";
-// 통합 검색 유형 정의
-export const UnifiedSearchTypeSchema = z.enum([
-    "general", // 일반 검색
-    "trend" // 트렌드 검색
-]).describe("검색 방식 - general: 일반 검색, trend: 트렌드 분석");
-// 일반 검색 유형 정의
-export const GeneralSearchTypeSchema = z.enum([
-    "all", // 모든 검색
-    "webkr", // 웹문서
-    "news", // 뉴스
-    "blog", // 블로그
-    "shop", // 쇼핑
-    "image", // 이미지
-    "kin", // 지식iN
-    "book", // 책
-    "encyc", // 지식백과
-    "academic", // 전문자료
-    "local", // 지역
-    "cafearticle" // 카페글
-]).describe("검색 카테고리 - all: 모든 카테고리 통합 검색, webkr: 웹문서, news: 뉴스, blog: 블로그, shop: 쇼핑, image: 이미지, kin: 지식iN, book: 책, encyc: 지식백과, academic: 전문자료, local: 지역, cafearticle: 카페글");
-// 트렌드 검색 유형 정의
-export const TrendSearchTypeSchema = z.enum([
-    "all", // 모든 트렌드 검색
-    "search", // 검색어 트렌드
-    "shopping_category", // 쇼핑 카테고리별 트렌드
-    "shopping_by_device", // 쇼핑 기기별 트렌드
-    "shopping_by_gender", // 쇼핑 성별 트렌드
-    "shopping_by_age", // 쇼핑 연령별 트렌드
-    "shopping_keywords", // 쇼핑 키워드별 트렌드
-    "shopping_keyword_by_device", // 쇼핑 키워드 기기별 트렌드
-    "shopping_keyword_by_gender", // 쇼핑 키워드 성별 트렌드 
-    "shopping_keyword_by_age" // 쇼핑 키워드 연령별 트렌드
-]).describe("트렌드 분석 유형 - all: 모든 트렌드 통합 검색, search: 일반 검색어 트렌드, shopping_category: 쇼핑 카테고리별 트렌드, shopping_by_device: 쇼핑 기기별(PC/모바일) 트렌드, shopping_by_gender: 쇼핑 성별 트렌드, shopping_by_age: 쇼핑 연령별 트렌드, shopping_keywords: 쇼핑 키워드별 트렌드, shopping_keyword_by_device: 쇼핑 키워드 기기별 트렌드, shopping_keyword_by_gender: 쇼핑 키워드 성별 트렌드, shopping_keyword_by_age: 쇼핑 키워드 연령별 트렌드");
-// 통합 검색 베이스 스키마
-export const UnifiedSearchBaseSchema = z.object({
-    searchType: UnifiedSearchTypeSchema.describe("검색 유형 (일반/트렌드)"),
-});
-// 일반 검색 스키마
-export const GeneralSearchSchema = UnifiedSearchBaseSchema.extend({
-    searchType: z.literal("general"),
-    generalType: GeneralSearchTypeSchema.describe("일반 검색 유형"),
-    params: z.union([
-        SearchArgsSchema,
-        NaverLocalSearchParamsSchema
-    ]).describe("검색 매개변수")
-});
-// 트렌드 검색 스키마
-export const TrendSearchSchema = UnifiedSearchBaseSchema.extend({
-    searchType: z.literal("trend"),
-    trendType: TrendSearchTypeSchema.describe("트렌드 검색 유형"),
-    params: z.union([
-        DatalabSearchSchema,
-        DatalabShoppingSchema,
-        DatalabShoppingDeviceSchema,
-        DatalabShoppingGenderSchema,
-        DatalabShoppingAgeSchema,
-        DatalabShoppingKeywordsSchema,
-        DatalabShoppingKeywordDeviceSchema,
-        DatalabShoppingKeywordGenderSchema,
-        DatalabShoppingKeywordAgeSchema
-    ]).describe("트렌드 검색 매개변수")
-});
-// 통합 검색 스키마
-export const UnifiedSearchSchema = z.union([
-    GeneralSearchSchema,
-    TrendSearchSchema
-]);

package/dist/src/tools/unified-search.tools.js

@@ -1,14 +0,0 @@
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { UnifiedSearchSchema } from "../schemas/unified-search.schemas.js";
-/**
- * 통합 검색 도구
- * 일반 검색과 트렌드 검색을 통합해 하나의 인터페이스로 제공
- * 'all' 옵션을 사용하면 여러 검색을 병렬로 처리하여 모든 결과를 한 번에 반환
- */
-export const unifiedSearchTools = [
-    {
-        name: "unified_search",
-        description: "Perform a unified search for either general content or trend analysis. Use 'all' for generalType or trendType to search across all categories in parallel. (일반 콘텐츠 검색 또는 트렌드 분석을 위한 통합 검색. generalType 또는 trendType에 'all'을 사용하면 모든 카테고리를 병렬로 검색 가능)",
-        inputSchema: zodToJsonSchema(UnifiedSearchSchema),
-    }
-];

package/dist/tests/unified-search.handlers.test.js

@@ -1,194 +0,0 @@
-/**
- * unified-search.handlers.test.ts
- *
- * 통합 검색 핸들러에 대한 테스트
- */
-import { handleUnifiedSearch } from '../src/handlers/unified-search.handlers.js';
-import { NaverSearchClient } from '../src/clients/naver-search.client.js';
-// NaverSearchClient 모킹
-jest.mock('../src/clients/naver-search.client.js', () => {
-    const mockInstance = {
-        search: jest.fn(),
-        searchAcademic: jest.fn(),
-        searchLocal: jest.fn(),
-        searchTrend: jest.fn(),
-        datalabShoppingCategory: jest.fn(),
-        datalabShoppingByDevice: jest.fn(),
-        datalabShoppingByGender: jest.fn(),
-        datalabShoppingByAge: jest.fn(),
-        datalabShoppingKeywords: jest.fn(),
-        datalabShoppingKeywordByDevice: jest.fn(),
-        datalabShoppingKeywordByGender: jest.fn(),
-        datalabShoppingKeywordByAge: jest.fn(),
-    };
-    return {
-        getInstance: jest.fn(() => mockInstance),
-        __mockInstance: mockInstance
-    };
-});
-// 테스트 전에 모든 모의 함수 초기화
-beforeEach(() => {
-    jest.clearAllMocks();
-});
-// 모킹된 클라이언트 인스턴스 가져오기
-const mockClient = NaverSearchClient.getInstance().__mockInstance;
-describe('Unified Search Handlers', () => {
-    describe('handleUnifiedSearch - General Search', () => {
-        it('일반 검색 - 단일 유형(webkr)을 처리한다', async () => {
-            // 모의 응답 설정
-            const mockResponse = { items: [{ title: '테스트 결과' }] };
-            mockClient.search.mockResolvedValue(mockResponse);
-            // 테스트 호출
-            const result = await handleUnifiedSearch({
-                searchType: 'general',
-                generalType: 'webkr',
-                params: {
-                    query: '테스트 검색어',
-                    display: 10,
-                    sort: 'sim'
-                }
-            });
-            // 검증
-            expect(mockClient.search).toHaveBeenCalledWith('webkr', {
-                query: '테스트 검색어',
-                display: 10,
-                sort: 'sim'
-            });
-            expect(result).toEqual(mockResponse);
-        });
-        it('일반 검색 - 모든 유형(all)을 병렬 처리한다', async () => {
-            const mockWebkrResponse = { items: [{ title: '웹문서 결과' }] };
-            const mockNewsResponse = { items: [{ title: '뉴스 결과' }] };
-            const mockBlogResponse = { items: [{ title: '블로그 결과' }] };
-            mockClient.search.mockImplementation((type, params) => {
-                switch (type) {
-                    case 'webkr': return Promise.resolve(mockWebkrResponse);
-                    case 'news': return Promise.resolve(mockNewsResponse);
-                    case 'blog': return Promise.resolve(mockBlogResponse);
-                    default: return Promise.resolve({ items: [] });
-                }
-            });
-            mockClient.searchLocal.mockResolvedValue({ items: [{ title: '지역 결과' }] });
-            mockClient.searchAcademic.mockResolvedValue({ items: [{ title: '전문자료 결과' }] });
-            // 테스트 호출
-            const result = await handleUnifiedSearch({
-                searchType: 'general',
-                generalType: 'all',
-                params: {
-                    query: '통합 검색어',
-                    display: 5,
-                    sort: 'sim'
-                }
-            });
-            // 검증
-            expect(mockClient.search).toHaveBeenCalled();
-            expect(mockClient.searchLocal).toHaveBeenCalled();
-            expect(result).toHaveProperty('webkr');
-            expect(result).toHaveProperty('news');
-            expect(result).toHaveProperty('blog');
-            expect(result).toHaveProperty('local');
-        });
-    });
-    describe('handleUnifiedSearch - Trend Search', () => {
-        it('트렌드 검색 - 단일 유형(search)을 처리한다', async () => {
-            // 모의 응답 설정
-            const mockResponse = { results: [{ data: [{ period: '2023-01-01', ratio: 100 }] }] };
-            mockClient.searchTrend.mockResolvedValue(mockResponse);
-            // 테스트 호출
-            const result = await handleUnifiedSearch({
-                searchType: 'trend',
-                trendType: 'search',
-                params: {
-                    startDate: '2023-01-01',
-                    endDate: '2023-01-31',
-                    timeUnit: 'date',
-                    keywordGroups: [{
-                            groupName: '게임',
-                            keywords: ['롤', '피파']
-                        }]
-                }
-            });
-            // 검증
-            expect(mockClient.searchTrend).toHaveBeenCalledWith({
-                startDate: '2023-01-01',
-                endDate: '2023-01-31',
-                timeUnit: 'date',
-                keywordGroups: [{
-                        groupName: '게임',
-                        keywords: ['롤', '피파']
-                    }]
-            });
-            expect(result).toEqual(mockResponse);
-        });
-        it('트렌드 검색 - 모든 유형(all)을 병렬 처리한다', async () => {
-            // 모의 응답 설정
-            const mockSearchResponse = { results: [{ title: '검색어 트렌드' }] };
-            const mockCategoryResponse = { results: [{ title: '카테고리 트렌드' }] };
-            mockClient.searchTrend.mockResolvedValue(mockSearchResponse);
-            mockClient.datalabShoppingCategory.mockResolvedValue(mockCategoryResponse);
-            mockClient.datalabShoppingByDevice.mockResolvedValue({ results: [{ title: '기기별 트렌드' }] });
-            mockClient.datalabShoppingKeywords.mockResolvedValue({ results: [{ title: '키워드 트렌드' }] });
-            // 테스트 호출
-            const result = await handleUnifiedSearch({
-                searchType: 'trend',
-                trendType: 'all',
-                params: {
-                    startDate: '2023-01-01',
-                    endDate: '2023-01-31',
-                    timeUnit: 'date',
-                    category: '50000000',
-                    keywordGroups: [{
-                            groupName: '게임',
-                            keywords: ['롤', '피파']
-                        }]
-                }
-            });
-            // 검증
-            expect(mockClient.searchTrend).toHaveBeenCalled();
-            expect(result).toHaveProperty('search');
-            // category 파라미터가 있으면 쇼핑 관련 함수들도 호출된다
-            expect(mockClient.datalabShoppingCategory).toHaveBeenCalled();
-            expect(mockClient.datalabShoppingByDevice).toHaveBeenCalled();
-            expect(result).toHaveProperty('shopping_category');
-            expect(result).toHaveProperty('shopping_by_device');
-        });
-    });
-    describe('Error Handling', () => {
-        it('일반 검색에서 에러 발생 시 에러 메시지를 포함한 응답을 반환한다', async () => {
-            // 에러 발생 시뮬레이션
-            mockClient.search.mockRejectedValue(new Error('API 에러'));
-            // 테스트 호출
-            await expect(handleUnifiedSearch({
-                searchType: 'general',
-                generalType: 'webkr',
-                params: { query: '에러 테스트' }
-            })).rejects.toThrow('API 에러');
-        });
-        it('모든 검색에서 일부 API가 실패해도 성공한 결과는 반환한다', async () => {
-            mockClient.search.mockImplementation((type) => {
-                if (type === 'webkr') {
-                    return Promise.resolve({ items: [{ title: '웹문서 결과' }] });
-                }
-                else if (type === 'news') {
-                    return Promise.reject(new Error('뉴스 API 에러'));
-                }
-                else {
-                    return Promise.resolve({ items: [] });
-                }
-            });
-            // 테스트 호출
-            const result = await handleUnifiedSearch({
-                searchType: 'general',
-                generalType: 'all',
-                params: { query: '부분 에러 테스트' }
-            });
-            // 성공한 API 결과 확인
-            expect(result).toHaveProperty('webkr');
-            expect(result.webkr).toEqual({ items: [{ title: '웹문서 결과' }] });
-            // 실패한 API 결과 확인
-            expect(result).toHaveProperty('news');
-            expect(result.news).toHaveProperty('error');
-            expect(result.news.error).toBe('뉴스 API 에러');
-        });
-    });
-});

package/dist/tests/unified-search.schemas.test.js

@@ -1,187 +0,0 @@
-/**
- * unified-search.schemas.test.ts
- *
- * 통합 검색 스키마에 대한 테스트
- */
-import { UnifiedSearchSchema, GeneralSearchSchema, TrendSearchSchema, GeneralSearchTypeSchema, TrendSearchTypeSchema } from '../src/schemas/unified-search.schemas.js';
-describe('Unified Search Schemas', () => {
-    describe('GeneralSearchTypeSchema', () => {
-        it('"all" 옵션을 포함한다', () => {
-            const values = Object.values(GeneralSearchTypeSchema.enum);
-            expect(values).toContain('all');
-        });
-        it('모든 일반 검색 타입을 포함한다', () => {
-            const values = Object.values(GeneralSearchTypeSchema.enum);
-            const expectedTypes = [
-                'all', 'webkr', 'news', 'blog', 'shop', 'image',
-                'kin', 'book', 'encyc', 'academic', 'local', 'cafearticle'
-            ];
-            expectedTypes.forEach(type => {
-                expect(values).toContain(type);
-            });
-        });
-    });
-    describe('TrendSearchTypeSchema', () => {
-        it('"all" 옵션을 포함한다', () => {
-            const values = Object.values(TrendSearchTypeSchema.enum);
-            expect(values).toContain('all');
-        });
-        it('모든 트렌드 검색 타입을 포함한다', () => {
-            const values = Object.values(TrendSearchTypeSchema.enum);
-            const expectedTypes = [
-                'all', 'search', 'shopping_category', 'shopping_by_device',
-                'shopping_by_gender', 'shopping_by_age', 'shopping_keywords',
-                'shopping_keyword_by_device', 'shopping_keyword_by_gender',
-                'shopping_keyword_by_age'
-            ];
-            expectedTypes.forEach(type => {
-                expect(values).toContain(type);
-            });
-        });
-    });
-    describe('GeneralSearchSchema', () => {
-        it('유효한 일반 검색 객체를 검증한다', () => {
-            // 유효한 일반 검색 객체
-            const validGeneralSearch = {
-                searchType: 'general',
-                generalType: 'webkr',
-                params: {
-                    query: '테스트 검색어',
-                    display: 10,
-                    sort: 'sim'
-                }
-            };
-            // 스키마 검증 시 에러가 발생하지 않아야 함
-            expect(() => GeneralSearchSchema.parse(validGeneralSearch)).not.toThrow();
-        });
-        it('유효한 일반 검색 all 옵션을 검증한다', () => {
-            // all 옵션을 사용한 유효한 일반 검색 객체
-            const validAllGeneralSearch = {
-                searchType: 'general',
-                generalType: 'all',
-                params: {
-                    query: '통합 검색어',
-                    display: 5
-                }
-            };
-            expect(() => GeneralSearchSchema.parse(validAllGeneralSearch)).not.toThrow();
-        });
-        it('유효하지 않은 일반 검색 객체를 거부한다', () => {
-            // 필수 필드 누락
-            const missingParams = {
-                searchType: 'general',
-                generalType: 'webkr'
-                // params 누락
-            };
-            // 잘못된 generalType
-            const invalidType = {
-                searchType: 'general',
-                generalType: 'invalid-type',
-                params: { query: '검색어' }
-            };
-            // 필수 필드가 없으면 에러가 발생해야 함
-            expect(() => GeneralSearchSchema.parse(missingParams)).toThrow();
-            // 잘못된 타입이면 에러가 발생해야 함
-            expect(() => GeneralSearchSchema.parse(invalidType)).toThrow();
-        });
-    });
-    describe('TrendSearchSchema', () => {
-        it('유효한 트렌드 검색 객체를 검증한다', () => {
-            // 유효한 트렌드 검색 객체
-            const validTrendSearch = {
-                searchType: 'trend',
-                trendType: 'search',
-                params: {
-                    startDate: '2023-01-01',
-                    endDate: '2023-01-31',
-                    timeUnit: 'date',
-                    keywordGroups: [{
-                            groupName: '게임',
-                            keywords: ['롤', '피파']
-                        }]
-                }
-            };
-            expect(() => TrendSearchSchema.parse(validTrendSearch)).not.toThrow();
-        });
-        it('유효한 트렌드 검색 all 옵션을 검증한다', () => {
-            // all 옵션을 사용한 유효한 트렌드 검색 객체
-            const validAllTrendSearch = {
-                searchType: 'trend',
-                trendType: 'all',
-                params: {
-                    startDate: '2023-01-01',
-                    endDate: '2023-01-31',
-                    timeUnit: 'date',
-                    category: '50000000',
-                    keywordGroups: [{
-                            groupName: '게임',
-                            keywords: ['롤', '피파']
-                        }]
-                }
-            };
-            expect(() => TrendSearchSchema.parse(validAllTrendSearch)).not.toThrow();
-        });
-        it('유효하지 않은 트렌드 검색 객체를 거부한다', () => {
-            // 필수 필드 누락
-            const missingParams = {
-                searchType: 'trend',
-                trendType: 'search'
-                // params 누락
-            };
-            // 잘못된 trendType
-            const invalidType = {
-                searchType: 'trend',
-                trendType: 'invalid-type',
-                params: {
-                    startDate: '2023-01-01',
-                    endDate: '2023-01-31',
-                    timeUnit: 'date'
-                }
-            };
-            // 필수 필드가 없으면 에러가 발생해야 함
-            expect(() => TrendSearchSchema.parse(missingParams)).toThrow();
-            // 잘못된 타입이면 에러가 발생해야 함
-            expect(() => TrendSearchSchema.parse(invalidType)).toThrow();
-        });
-    });
-    describe('UnifiedSearchSchema', () => {
-        it('일반 검색과 트렌드 검색 객체를 모두 허용한다', () => {
-            // 유효한 일반 검색 객체
-            const validGeneralSearch = {
-                searchType: 'general',
-                generalType: 'webkr',
-                params: {
-                    query: '테스트 검색어',
-                    display: 10
-                }
-            };
-            // 유효한 트렌드 검색 객체
-            const validTrendSearch = {
-                searchType: 'trend',
-                trendType: 'search',
-                params: {
-                    startDate: '2023-01-01',
-                    endDate: '2023-01-31',
-                    timeUnit: 'date',
-                    keywordGroups: [{
-                            groupName: '게임',
-                            keywords: ['롤', '피파']
-                        }]
-                }
-            };
-            expect(() => UnifiedSearchSchema.parse(validGeneralSearch)).not.toThrow();
-            expect(() => UnifiedSearchSchema.parse(validTrendSearch)).not.toThrow();
-        });
-        it('유효하지 않은 검색 유형을 거부한다', () => {
-            // 잘못된 searchType
-            const invalidSearchType = {
-                searchType: 'invalid-type',
-                generalType: 'webkr',
-                params: {
-                    query: '테스트 검색어'
-                }
-            };
-            expect(() => UnifiedSearchSchema.parse(invalidSearchType)).toThrow();
-        });
-    });
-});

package/dist/tests/unified-search.tools.test.js

@@ -1,38 +0,0 @@
-/**
- * unified-search.tools.test.ts
- *
- * 통합 검색 도구에 대한 테스트
- */
-import { unifiedSearchTools } from '../src/tools/unified-search.tools.js';
-describe('Unified Search Tools', () => {
-    it('통합 검색 도구가 정의되어 있다', () => {
-        expect(unifiedSearchTools).toBeDefined();
-        expect(Array.isArray(unifiedSearchTools)).toBe(true);
-        expect(unifiedSearchTools.length).toBeGreaterThan(0);
-    });
-    it('통합 검색 도구가 올바른 구조를 가지고 있다', () => {
-        const unifiedSearchTool = unifiedSearchTools[0];
-        expect(unifiedSearchTool).toHaveProperty('name', 'unified_search');
-        expect(unifiedSearchTool).toHaveProperty('description');
-        expect(unifiedSearchTool).toHaveProperty('inputSchema');
-    });
-    it('통합 검색 도구 설명에 "all" 옵션에 대한 정보가 포함되어 있다', () => {
-        const unifiedSearchTool = unifiedSearchTools[0];
-        expect(unifiedSearchTool.description).toContain('all');
-        expect(unifiedSearchTool.description).toContain('통합 검색');
-    });
-    it('통합 검색 도구의 스키마가 올바르게 정의되어 있다', () => {
-        const unifiedSearchTool = unifiedSearchTools[0];
-        const schema = unifiedSearchTool.inputSchema;
-        // 스키마가 객체이고 필요한 속성을 가지고 있는지 확인
-        expect(typeof schema).toBe('object');
-        expect(schema).toBeDefined();
-        // 스키마가 JSON Schema 형식인지 확인
-        expect(schema).toHaveProperty('$schema');
-        // 스키마가 일반 검색과 트렌드 검색을 포함하는지 간접적으로 확인
-        const schemaStr = JSON.stringify(schema);
-        expect(schemaStr).toContain('general');
-        expect(schemaStr).toContain('trend');
-        expect(schemaStr).toContain('all');
-    });
-});