@axboot-mcp/mcp-server 1.0.0

package/src/index.ts

@@ -0,0 +1,959 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { analyzeInterface } from './handlers/analyze.js';
+import { generateStore } from './handlers/generate.js';
+import { generateHook } from './handlers/generate-hook.js';
+import * as path from 'path';
+import { analyzeRequirements } from './handlers/analyze-requirements.js';
+import { generateStoreFromRequirements } from './handlers/generate-from-requirements.js';
+import { generateMultiStores, detectMultiListPattern } from './handlers/generate-multi-stores.js';
+import { generateRequirementsFromLayout } from './handlers/generate-requirements-from-layout.js';
+import { suggestLayout } from './handlers/suggest-layout.js';
+import { getNHLayoutTypes } from './config/nh-layout-patterns.js';
+import { generateSearchParams } from './handlers/generate-search-params.js';
+import { generateListDataGrid } from './handlers/generate-listdatagrid.js';
+import { generateStoreAndHookInteractive } from './handlers/generate-interactive.js';
+import { scanMetadata } from './handlers/scan-metadata.js';
+import { existsSync, unlinkSync, readFileSync } from 'fs';
+import * as chokidar from 'chokidar';
+
+// ========== 파일 감시 관리자 ==========
+
+/**
+ * 프로젝트별 파일 감시자 관리
+ */
+const projectWatchers = new Map<string, chokidar.FSWatcher>();
+
+/**
+ * 프로젝트의 파일 감시 시작
+ * - DTO, Repository, Code, Modal 파일 변경 시 캐시 삭제
+ */
+function startWatching(projectRoot: string): void {
+  // 이미 감시 중이면 무시
+  if (projectWatchers.has(projectRoot)) {
+    return;
+  }
+
+  const cachePath = path.join(projectRoot, '.claude', 'mcp-cache', 'search-params-meta.json');
+
+  // 감시할 파일 패턴
+  const watchPatterns = [
+    'src/services/@interface/dto/**/*.ts',
+    'src/services/**/dto/**/*.ts',
+    'src/types/**/*Dto*.ts',
+    'src/types/**/*.ts',  // DefaultDto 등 포함
+    'src/@types/**/*.ts',  // DefaultDto 포함
+    'src/services/@interface/types/**/*.ts',  // DefaultDto 포함
+    'src/interfaces/**/*Request*.ts',
+    'src/interfaces/**/*Response*.ts',
+    'src/services/**/*Repository.ts',
+    'src/services/**/repository/*.ts',
+    'src/stores/**/*.ts',
+    'src/**/useCodeStore.ts',
+    'src/modals/**/*Modal.ts',
+    'src/components/**/*Modal.ts',
+  ];
+
+  const watcher = chokidar.watch(watchPatterns, {
+    cwd: projectRoot,
+    ignoreInitial: true,
+    persistent: true,
+  });
+
+  // 파일 변경 시 캐시 삭제
+  watcher.on('change', () => {
+    try {
+      if (existsSync(cachePath)) {
+        unlinkSync(cachePath);
+        console.error(`[MCP] 캐시 삭제 (파일 변경 감지): ${cachePath}`);
+      }
+    } catch (e) {
+      // 무시
+    }
+  });
+
+  watcher.on('add', () => {
+    try {
+      if (existsSync(cachePath)) {
+        unlinkSync(cachePath);
+        console.error(`[MCP] 캐시 삭제 (파일 추가 감지): ${cachePath}`);
+      }
+    } catch (e) {
+      // 무시
+    }
+  });
+
+  watcher.on('unlink', () => {
+    try {
+      if (existsSync(cachePath)) {
+        unlinkSync(cachePath);
+        console.error(`[MCP] 캐시 삭제 (파일 삭제 감지): ${cachePath}`);
+      }
+    } catch (e) {
+      // 무시
+    }
+  });
+
+  projectWatchers.set(projectRoot, watcher);
+  console.error(`[MCP] 파일 감시 시작: ${projectRoot}`);
+}
+
+/**
+ * 프로젝트의 파일 감시 중지
+ */
+function stopWatching(projectRoot: string): void {
+  const watcher = projectWatchers.get(projectRoot);
+  if (watcher) {
+    watcher.close();
+    projectWatchers.delete(projectRoot);
+    console.error(`[MCP] 파일 감시 중지: ${projectRoot}`);
+  }
+}
+
+// ========== 자동 스캔 헬퍼 ==========
+
+/**
+ * 파일 경로에서 프로젝트 루트 추출
+ * - src/, package.json, tsconfig.json 등이 있는 경로를 찾음
+ */
+function extractProjectRoot(filePath: string): string {
+  const normalizedPath = path.normalize(filePath);
+
+  // 이미 루트 경로인지 확인 (src, package.json 등이 있으면)
+  const possibleRoots = [
+    path.dirname(normalizedPath),  // 파일의 디렉토리
+    path.dirname(path.dirname(normalizedPath)),  // 그 상위 디렉토리
+    path.dirname(path.dirname(path.dirname(normalizedPath))),  // 그 상위 디렉토리
+  ];
+
+  for (const root of possibleRoots) {
+    if (root === path.normalize('/')) continue;  // 루트 디렉토리는 제외
+
+    // 프로젝트 루트 표식 확인
+    const hasProjectMarkers = [
+      path.join(root, 'package.json'),
+      path.join(root, 'tsconfig.json'),
+      path.join(root, 'src'),
+    ].some(marker => existsSync(marker));
+
+    if (hasProjectMarkers) {
+      return root;
+    }
+  }
+
+  // 기본: 파일의 디렉토리 반환
+  return path.dirname(normalizedPath);
+}
+
+/**
+ * 메타데이터 자동 스캔 보장
+ * - 캐시가 없거나 만료된 경우 자동으로 스캔
+ * - 파일 감시자 시작
+ */
+async function ensureScanned(projectRoot: string): Promise<void> {
+  // 파일 감시 시작 (백그라운드)
+  startWatching(projectRoot);
+
+  const cachePath = path.join(projectRoot, '.claude', 'mcp-cache', 'search-params-meta.json');
+
+  // 캐시 확인
+  if (existsSync(cachePath)) {
+    try {
+      const cacheContent = await import('fs').then(fs => fs.promises.readFile(cachePath, 'utf-8'));
+      const cache = JSON.parse(cacheContent);
+
+      // 캐시 유효성 확인 (파일 감시 모드에서는 1시간 제한 없음)
+      // 단순히 캐시가 존재하면 사용
+      return;  // 캐시 유효함
+    } catch {
+      // 캐시 손상 → 재스캔
+    }
+  }
+
+  // 스캔 실행 (조용히, 에러 무시)
+  try {
+    await scanMetadata({ projectRoot, forceRescan: false });
+  } catch (e) {
+    // 스캔 실패해도 툴 실행은 계속
+  }
+}
+
+// MCP 서버 생성
+const server = new Server(
+  {
+    name: 'mcp-axboot',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+      prompts: {},
+    },
+  }
+);
+
+// 프롬프트 목록 등록
+server.setRequestHandler(ListPromptsRequestSchema, async () => {
+  return {
+    prompts: [
+      {
+        name: 'search-params-guide',
+        description: 'NH-FE-B 패턴의 SearchParams 컴포넌트 생성 가이드. 사용자가 "search params 만들어줘: dateRange code:STATUS_CODE search" 같은 요청을 하면 이 가이드를 참고하세요.',
+      },
+    ],
+  };
+});
+
+// 프롬프트 가져오기
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+  const { name } = request.params;
+
+  if (name === 'search-params-guide') {
+    const promptPath = path.join(__dirname, 'prompts', 'search-params.md');
+    const content = readFileSync(promptPath, 'utf-8');
+
+    return {
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: content,
+          },
+        },
+      ],
+    };
+  }
+
+  throw new Error(`Unknown prompt: ${name}`);
+});
+
+// 도구 목록 등록
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: 'analyze_interface',
+        description: '인터페이스 Repository 파일을 분석하여 Service 메서드와 타입 정보 추출',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            interfacePath: {
+              type: 'string',
+              description: '인터페이스 Repository 파일 경로 (절대 경로)',
+            },
+          },
+          required: ['interfacePath'],
+        },
+      },
+      {
+        name: 'generate_store',
+        description: '분석된 인터페이스 정보를 기반으로 Zustand Store 파일 생성',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            interfacePath: {
+              type: 'string',
+              description: '인터페이스 Repository 파일 경로 (절대 경로)',
+            },
+            outputPath: {
+              type: 'string',
+              description: '생성할 Store 파일 경로 (절대 경로)',
+            },
+            storeType: {
+              type: 'number',
+              description: 'Store 타입 (1: 기본+상세, 2: 마스터-디테일+모달+삭제, 3: 트리, 4: 대시보드, 5: 단순, 6: 재정렬, 7: 마스터-디테일+모달+삭제+엑셀, 8: 리스트+선택+엑셀, 9: 마스터-디테일+모달+상세조회, 10: 마스터-디테일+엑셀)',
+              default: 1,
+              enum: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+            },
+            storeName: {
+              type: 'string',
+              description: 'Store 이름 (camelCase, 예: useMemberListStore)',
+              default: 'useGeneratedStore',
+            },
+          },
+          required: ['interfacePath', 'outputPath'],
+        },
+      },
+      {
+        name: 'analyze_requirements',
+        description: '자연어 요구사항을 분석하여 필요한 Store 피처 추출 및 적합한 타입 추천',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            requirements: {
+              type: 'string',
+              description: 'Store 요구사항 (자연어)',
+            },
+          },
+          required: ['requirements'],
+        },
+      },
+      {
+        name: 'generate_store_from_requirements',
+        description: '요구사항 기반으로 Store 파일 자동 생성 (적합한 타입 자동 선택, 다중 리스트 자동 감지)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            interfacePath: {
+              type: 'string',
+              description: '인터페이스 Repository 파일 경로 (절대 경로)',
+            },
+            outputPath: {
+              type: 'string',
+              description: '생성할 Store 파일 경로 (절대 경로, 예: /path/to/useOrderStore.ts)',
+            },
+            requirements: {
+              type: 'string',
+              description: 'Store 요구사항 (자연어, 예: 왼쪽 목록, 상단 디테일 목록, 하단 디테일 목록, 각 목록은 검색과 엑셀 다운로드, 하단은 체크박스)',
+            },
+          },
+          required: ['interfacePath', 'outputPath', 'requirements'],
+        },
+      },
+      {
+        name: 'generate_multi_stores',
+        description: '다중 리스트 통합 Store 생성 (왼쪽/상단/하단 목록 등을 하나의 Store로 통합)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            interfacePath: {
+              type: 'string',
+              description: '인터페이스 Repository 파일 경로 (절대 경로)',
+            },
+            outputPath: {
+              type: 'string',
+              description: '생성할 Store 파일 경로 (절대 경로, 예: /path/to/useOrderStore.ts)',
+            },
+            requirements: {
+              type: 'string',
+              description: 'Store 요구사항 (자연어, 예: 왼쪽 목록, 상단 디테일 목록, 하단 디테일 목록, 각 목록은 검색과 엑셀 다운로드, 하단은 체크박스)',
+            },
+            baseStoreName: {
+              type: 'string',
+              description: 'Store 파일명 (예: useOrderStore)',
+            },
+          },
+          required: ['interfacePath', 'outputPath', 'requirements', 'baseStoreName'],
+        },
+      },
+      {
+        name: 'detect_multi_list_pattern',
+        description: '요구사항에서 다중 리스트 패턴 감지',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            requirements: {
+              type: 'string',
+              description: 'Store 요구사항 (자연어)',
+            },
+          },
+          required: ['requirements'],
+        },
+      },
+      {
+        name: 'generate_requirements_from_layout',
+        description: 'NH 레이아웃 패턴과 Repository를 기반으로 요구사항 생성',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            interfacePath: {
+              type: 'string',
+              description: '인터페이스 Repository 파일 경로 (절대 경로)',
+            },
+            layoutType: {
+              type: 'string',
+              description: 'NH 레이아웃 타입 (LEFT_DETAIL_FORM, LEFT_DETAIL_LIST, MULTI_PANEL, LIST_DRAWER, LIST_MODAL, TAB_BASED, LIST_SUMMARY, DASHBOARD, FORM_ONLY)',
+            },
+            additional: {
+              type: 'string',
+              description: '추가 요구사항 (선택사항)',
+            },
+          },
+          required: ['interfacePath', 'layoutType'],
+        },
+      },
+      {
+        name: 'list_layouts',
+        description: '사용 가능한 NH 레이아웃 패턴 목록 조회',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+        },
+      },
+      {
+        name: 'suggest_layout',
+        description: 'Repository를 분석하여 가장 적합한 NH 레이아웃 패턴 추천',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            interfacePath: {
+              type: 'string',
+              description: '인터페이스 Repository 파일 경로 (절대 경로)',
+            },
+          },
+          required: ['interfacePath'],
+        },
+      },
+      {
+        name: 'generate_search_params',
+        description: 'App.tsx에 추가되는 SearchParams JSX 코드 생성 (NH-FE-B 패턴 기반)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            appPath: {
+              type: 'string',
+              description: 'App.tsx 파일 경로 (절대 경로)',
+            },
+            searchParams: {
+              type: 'object',
+              description: 'SearchParams 설정',
+              properties: {
+                dateRange: {
+                  type: 'object',
+                  description: '날짜 범위 검색 설정',
+                  properties: {
+                    withPeriodType: { type: 'boolean', description: '기간구분 포함 여부' },
+                    periodOptions: {
+                      type: 'array',
+                      description: '기간구분 옵션',
+                      items: {
+                        type: 'object',
+                        properties: {
+                          label: { type: 'string' },
+                          value: { type: 'string' },
+                        },
+                      },
+                    },
+                    name: { type: 'string', description: '날짜 필드명 (기본: dateRange)' },
+                    label: { type: 'string', description: '라벨 (기본: 등록일)' },
+                    presetType: { type: 'string', enum: ['all', 'default'], description: '프리셋 타입' },
+                  },
+                },
+                codes: {
+                  type: 'array',
+                  description: '코드 선택 필드 목록',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      name: { type: 'string', description: '코드 필드명 (예: statusCd)' },
+                      label: { type: 'string', description: '라벨 (예: 상태)' },
+                      codeVar: { type: 'string', description: '코드 변수명 (예: STATUS_CODE)' },
+                      width: { type: 'number', description: '너비 (기본: 150)' },
+                      multi: { type: 'boolean', description: '다중 선택 여부' },
+                    },
+                    required: ['name', 'label'],
+                  },
+                },
+                search: {
+                  type: 'object',
+                  description: '검색어 설정',
+                  properties: {
+                    withSearchType: { type: 'boolean', description: '검색구분 포함 여부' },
+                    options: {
+                      type: 'array',
+                      description: '검색구분 옵션',
+                      items: {
+                        type: 'object',
+                        properties: {
+                          label: { type: 'string' },
+                          value: { type: 'string' },
+                        },
+                      },
+                    },
+                    textName: { type: 'string', description: '검색어 필드명 (기본: searchText)' },
+                    typeName: { type: 'string', description: '검색구분 필드명 (기본: searchType)' },
+                  },
+                },
+                ynFields: {
+                  type: 'array',
+                  description: 'Y/N 필드 목록',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      name: { type: 'string', description: 'Y/N 필드명 (예: useYn)' },
+                      label: { type: 'string', description: '라벨 (예: 사용여부)' },
+                    },
+                    required: ['name', 'label'],
+                  },
+                },
+                numberRanges: {
+                  type: 'array',
+                  description: '숫자 범위 필드 목록',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      name: { type: 'string' },
+                      label: { type: 'string' },
+                      minPlaceholder: { type: 'string' },
+                      maxPlaceholder: { type: 'string' },
+                    },
+                    required: ['name', 'label'],
+                  },
+                },
+                lineBreak: { type: 'boolean', description: '줄바꿈 추가 여부' },
+              },
+            },
+          },
+          required: ['appPath', 'searchParams'],
+        },
+      },
+      {
+        name: 'generate_listdatagrid',
+        description: 'ListDataGrid.tsx 컴포넌트 생성 (NH-FE-B 패턴 기반)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            outputPath: {
+              type: 'string',
+              description: '생성할 ListDataGrid 파일 경로 (절대 경로)',
+            },
+            config: {
+              type: 'object',
+              description: 'ListDataGrid 설정',
+              properties: {
+                storeName: {
+                  type: 'string',
+                  description: 'Store 이름 (예: useProductListStore)',
+                },
+                dtoType: {
+                  type: 'string',
+                  description: 'DTO 타입 (예: ProductRes)',
+                },
+                rowKey: {
+                  type: 'string',
+                  description: '행 키 (예: id, prdCd)',
+                },
+                selectionMode: {
+                  type: 'string',
+                  enum: ['single', 'multi', 'none'],
+                  description: '선택 모드',
+                },
+                withFormHeader: {
+                  type: 'boolean',
+                  description: 'FormHeader 포함 여부',
+                },
+                withExcel: {
+                  type: 'boolean',
+                  description: '엑셀 다운로드 포함 여부',
+                },
+                columns: {
+                  type: 'array',
+                  description: '컬럼 정의',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      key: { type: 'string', description: '컬럼 키 (DTO 필드명)' },
+                      label: { type: 'string', description: '라벨' },
+                      type: {
+                        type: 'string',
+                        enum: ['rowNo', 'title', 'money', 'date', 'dateTime', 'user', 'selectable', 'custom'],
+                        description: '컬럼 타입',
+                      },
+                      align: {
+                        type: 'string',
+                        enum: ['left', 'center', 'right'],
+                        description: '정렬',
+                      },
+                      width: { type: 'number', description: '너비' },
+                      codeVar: { type: 'string', description: '코드 변수명 (코드 변환시 사용)' },
+                      itemRender: { type: 'string', description: 'itemRender 코드 (사용자 정의 렌더링)' },
+                    },
+                    required: ['key', 'label'],
+                  },
+                },
+                onClickType: {
+                  type: 'string',
+                  enum: ['modal', 'link', 'select', 'none'],
+                  description: 'onClickItem 동작 타입',
+                },
+                extraImports: {
+                  type: 'array',
+                  description: '추가적인 import',
+                  items: { type: 'string' },
+                },
+              },
+              required: ['storeName', 'dtoType', 'rowKey', 'columns'],
+            },
+          },
+          required: ['outputPath', 'config'],
+        },
+      },
+      {
+        name: 'generate_hook',
+        description: '리포지토리 인터페이스를 분석하여 React Hook 파일 생성 (목록/조회 API만 포함)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            interfacePath: {
+              type: 'string',
+              description: '인터페이스 Repository 파일 경로 (절대 경로)',
+            },
+            outputPath: {
+              type: 'string',
+              description: '생성할 Hook 파일 경로 (절대 경로, 기본: src/hooks/use{Entity}Service.ts)',
+            },
+          },
+          required: ['interfacePath'],
+        },
+      },
+      {
+        name: 'generate_store_and_hook_interactive',
+        description: '[CRITICAL] 대화형 Store와 Hook 생성 - 반드시 3단계로 진행하세요:\n\n1단계: [첫 호출] fileName만 전달 → 파일 후보 목록 반환\n  [CRITICAL] 1단계에서는 userSelections를 절대 포함하지 마세요!\n  [CRITICAL] 1단계에서는 fileIndex를 선택하지 말고 사용자에게 번호를 입력받으세요!\n\n2단계: fileIndex 전달 → 경로 제안 반환\n  - 제안된 경로로 생성: "확인", "진행" 등 → confirmed: true로 전달\n  - 경로 변경 후 생성: "store는 src/stores/useBannerStore.ts로" 등 → storePath/hookPath로 전달\n\n3단계: (2단계에서 confirmed 또는 storePath/hookPath를 지정하면 즉시 생성됨)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            fileName: {
+              type: 'string',
+              description: 'Repository 파일명 또는 자연어 검색어 (예: MemberRepository, "쿠폰", "회원"). 1단계에서만 사용합니다.',
+            },
+            userSelections: {
+              type: 'object',
+              description: '[CRITICAL] 2/3단계 전용. [CRITICAL] 1단계(첫 호출)에서는 절대 포함하지 마세요! [CRITICAL] 사용자가 명시적으로 파일 번호를 입력하기 전까지는 fileIndex를 설정하지 마세요!',
+              properties: {
+                fileIndex: {
+                  type: 'number',
+                  description: '[2단계] 선택한 파일 번호 (1부터 시작). 여러 파일 후보 중 선택할 때 사용합니다.',
+                },
+                storePath: {
+                  type: 'string',
+                  description: '[2/3단계] Store 경로 (사용자가 경로를 직접 지정할 때 사용). 예: "src/stores/useBannerStore.ts"',
+                  nullable: true,
+                },
+                hookPath: {
+                  type: 'string',
+                  description: '[2/3단계] Hook 경로 (사용자가 경로를 직접 지정할 때 사용). 예: "src/hooks/useBannerService.ts"',
+                  nullable: true,
+                },
+                confirmed: {
+                  type: 'boolean',
+                  description: '[3단계 전용] 경로 확인 완료 플래그. 사용자가 "확인", "생성", "진행" 등 명시적으로 동의했을 때만 true로 설정하세요. [CRITICAL] 1/2단계에서는 절대 true로 설정하지 마세요. 기본값은 false입니다.',
+                },
+              },
+            },
+            projectRoot: {
+              type: 'string',
+              description: '프로젝트 루트 경로 (선택사항, 기본: 현재 작업 디렉토리)',
+            },
+          },
+          required: ['fileName'],
+        },
+      },
+      {
+        name: 'scan_metadata',
+        description: '프로젝트 메타데이터 스캔 (DTO, Repository, Code, Modal) → .mcp-cache/에 저장',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            projectRoot: {
+              type: 'string',
+              description: '프로젝트 루트 경로 (절대 경로)',
+            },
+            forceRescan: {
+              type: 'boolean',
+              description: '강제 재스캔 여부 (기본: false, 캐시 있으면 사용)',
+            },
+          },
+          required: ['projectRoot'],
+        },
+      },
+    ],
+  };
+});
+
+// 도구 실행 핸들러
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  // args가 undefined인 경우 처리
+  const params = args || {};
+
+  try {
+    switch (name) {
+      case 'analyze_interface':
+        return await analyzeInterface(params as { interfacePath: string });
+
+      case 'generate_store':
+        await ensureScanned(extractProjectRoot((params as { interfacePath: string }).interfacePath));
+        return await generateStore(params as {
+          interfacePath: string;
+          outputPath: string;
+          storeType?: number;
+          storeName?: string;
+        });
+
+      case 'analyze_requirements':
+        return await analyzeRequirements(params as { requirements: string });
+
+      case 'generate_store_from_requirements':
+        await ensureScanned(extractProjectRoot((params as { interfacePath: string }).interfacePath));
+        return await generateStoreFromRequirements(params as {
+          interfacePath: string;
+          outputPath: string;
+          requirements: string;
+        });
+
+      case 'generate_multi_stores':
+        await ensureScanned(extractProjectRoot((params as { interfacePath: string }).interfacePath));
+        return await generateMultiStores({
+          interfacePath: (params as { interfacePath: string }).interfacePath,
+          outputPath: (params as { outputPath: string }).outputPath,
+          requirements: (params as { requirements: string }).requirements,
+          baseStoreName: (params as { baseStoreName: string }).baseStoreName,
+        });
+
+      case 'detect_multi_list_pattern':
+        const pattern = detectMultiListPattern((params as { requirements: string }).requirements);
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                isMultiList: pattern?.isMultiList || false,
+                pattern,
+              }),
+            },
+          ],
+        };
+
+      case 'generate_requirements_from_layout':
+        await ensureScanned(extractProjectRoot((params as { interfacePath: string }).interfacePath));
+        return await generateRequirementsFromLayout(params as {
+          interfacePath: string;
+          layoutType: string;
+          additional?: string;
+        });
+
+      case 'list_layouts':
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                layouts: getNHLayoutTypes(),
+              }),
+            },
+          ],
+        };
+
+      case 'suggest_layout':
+        await ensureScanned(extractProjectRoot((params as { interfacePath: string }).interfacePath));
+        return await suggestLayout(params as { interfacePath: string });
+
+      case 'generate_search_params':
+        await ensureScanned(extractProjectRoot((params as { appPath: string }).appPath));
+        return await generateSearchParams(params as {
+          appPath: string;
+          searchParams: import('./handlers/generate-search-params.js').SearchParamsConfig;
+        });
+
+      case 'generate_listdatagrid':
+        await ensureScanned(extractProjectRoot((params as { outputPath: string }).outputPath));
+        return await generateListDataGrid(params as {
+          outputPath: string;
+          config: import('./handlers/generate-listdatagrid.js').ListDataGridConfig;
+        });
+
+      case 'generate_hook':
+        await ensureScanned(extractProjectRoot((params as { interfacePath: string }).interfacePath));
+        return await generateHook(params as {
+          interfacePath: string;
+          outputPath?: string;
+        });
+
+      case 'generate_store_and_hook':
+        await ensureScanned(extractProjectRoot((params as { interfacePath: string }).interfacePath));
+        return await generateStoreAndHook(params as {
+          interfacePath: string;
+          storeOutputPath?: string;
+          hookOutputPath?: string;
+          storeName?: string;
+        });
+
+      case 'generate_store_and_hook_interactive':
+        const root = (params as { projectRoot?: string }).projectRoot || process.cwd();
+        await ensureScanned(root);
+        return await generateStoreAndHookInteractive(params as {
+          fileName: string;
+          userSelections?: {
+            fileIndex?: number;
+            storePath?: string | null;
+            hookPath?: string | null;
+          };
+          projectRoot?: string;
+        });
+
+      case 'scan_metadata':
+        return await scanMetadata(params as {
+          projectRoot: string;
+          forceRescan?: boolean;
+        });
+
+      default:
+        throw new Error(`알 수 없는 도구입니다: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+/**
+ * Store와 Hook 동시 생성 (결과 요약)
+ */
+async function generateStoreAndHook(args: {
+  interfacePath: string;
+  storeOutputPath?: string;
+  hookOutputPath?: string;
+  storeName?: string;
+}) {
+  const { interfacePath, storeOutputPath, hookOutputPath, storeName } = args;
+
+  // 1. 인터페이스 분석 (entityName 추출)
+  const analyzeResult = await analyzeInterface({ interfacePath });
+  const analyzeData = JSON.parse(analyzeResult.content[0].text);
+
+  if (!analyzeData.success) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          success: false,
+          error: analyzeData.error || '인터페이스 분석 실패',
+        }),
+      }],
+    };
+  }
+
+  const entityName = analyzeData.className?.replace('Repository', '') || 'Generated';
+
+  // 2. 경로 설정 (각각 지정 또는 자동 추정)
+  const finalStorePath = storeOutputPath || path.join('src', 'stores', `use${entityName}ListStore.ts`);
+  const finalHookPath = hookOutputPath || path.join('src', 'hooks', `use${entityName}Service.ts`);
+
+  // 3. Store 생성
+  const storeResult = await generateStore({
+    interfacePath,
+    outputPath: finalStorePath,
+    storeType: 1, // 통합 템플릿이므로 고정
+    storeName: storeName || `use${entityName}ListStore`,
+  });
+
+  const storeData = JSON.parse(storeResult.content[0].text);
+
+  // 4. Hook 생성
+  const hookResult = await generateHook({
+    interfacePath,
+    outputPath: finalHookPath,
+  });
+
+  const hookData = JSON.parse(hookResult.content[0].text);
+
+  // 5. 결과 요약
+  return {
+    content: [{
+      type: 'text',
+      text: formatSummary(storeData, hookData, finalStorePath, finalHookPath, entityName),
+    }],
+  };
+}
+
+/**
+ * 결과 요약 포맷팅
+ */
+function formatSummary(
+  storeData: any,
+  hookData: any,
+  storePath: string,
+  hookPath: string,
+  entityName: string
+): string {
+  const lines: string[] = [];
+
+  // 헤더
+  const hasErrors = storeData.typeErrors || hookData.typeErrors;
+  const icon = hasErrors ? '⚠️' : '✅';
+  const title = hasErrors ? 'Store 및 Hook 생성 완료 (일부 타입 오류)' : 'Store 및 Hook 생성 완료';
+
+  lines.push(`${icon} ${title}\n`);
+  lines.push(`엔티티: ${entityName}\n`);
+
+  // 생성된 파일
+  lines.push('생성된 파일:');
+  lines.push(`- ${storePath} (Store)`);
+  lines.push(`${hookPath} (Hook)\n`);
+
+  // 상태 요약
+  const storeStatus = storeData.typeErrors
+    ? `Store: 타입 오류 ${storeData.typeErrors.length}건`
+    : 'Store: 타입 체크 통과';
+  lines.push(storeStatus);
+
+  const hookStatus = hookData.typeErrors
+    ? `Hook: 타입 오류 ${hookData.typeErrors.length}건`
+    : 'Hook: 타입 체크 통과';
+  lines.push(hookStatus);
+
+  // 타입 오류가 있으면 추가
+  const allErrors = [
+    ...(storeData.typeErrors || []).map((e: string) => `[Store] ${e}`),
+    ...(hookData.typeErrors || []).map((e: string) => `[Hook] ${e}`),
+  ];
+
+  if (allErrors.length > 0) {
+    lines.push('\n타입 오류:');
+    allErrors.forEach(error => lines.push(`- ${error}`));
+  }
+
+  return lines.join('\n');
+}
+
+// 서버 시작
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('mcp-axboot server started');
+
+  // 시작 시 현재 작업 디렉토리 스캔 (백그라운드)
+  const cwd = process.cwd();
+
+  // 프로젝트 루트 확인 (package.json, src 등이 있으면)
+  const isProjectRoot = [
+    path.join(cwd, 'package.json'),
+    path.join(cwd, 'tsconfig.json'),
+    path.join(cwd, 'src'),
+  ].some(marker => existsSync(marker));
+
+  if (isProjectRoot) {
+    // 백그라운드에서 즉시 스캔 시작 (await 안 함)
+    ensureScanned(cwd).then(() => {
+      console.error(`[MCP] 백그라운드 스캔 완료: ${cwd}`);
+    }).catch(() => {
+      // 무시
+    });
+  }
+}
+
+main().catch((error) => {
+  console.error('Server error:', error);
+  process.exit(1);
+});