@axboot-mcp/mcp-server 1.0.0

package/src/handlers/list-templates.ts

@@ -0,0 +1,104 @@
+/**
+ * 사용 가능한 Store 템플릿 목록 반환
+ */
+export async function listTemplates(args: Record<string, unknown>) {
+  const templates = [
+    {
+      type: 1,
+      name: '기본 리스트 + 상세',
+      description: '선택된 아이템의 상세 정보 표시, 저장/수정 지원',
+      states: ['listSpinning', 'listData', 'listPage', 'selectedItem', 'detailLoading', 'saveRequestValue', 'checkedRowKeys'],
+      actions: ['callListApi', 'changeListPage', 'setSelectedItem', 'setCheckedRowKeys'],
+      useCases: ['회원 목록', '상품 목록', '쿠폰 목록'],
+    },
+    {
+      type: 2,
+      name: '마스터-디테일 + 모달 + 삭제',
+      description: '왼쪽 리스트, 오른쪽 상세, 모달, 삭제 기능 (B2B 패턴)',
+      states: ['listSpinning', 'listData', 'listPage', 'selectedItem', 'detail', 'detailSpinning', 'modalOpen', 'deleteSpinning', 'checkedRowKeys'],
+      actions: ['callListApi', 'changeListPage', 'setSelectedItem', 'setDetail', 'setModalOpen', 'callDeleteApi', 'setCheckedRowKeys'],
+      useCases: ['B2B 상품', '견적 상담', '구독 관리'],
+    },
+    {
+      type: 3,
+      name: '트리 기반',
+      description: '트리 구조 데이터, 펼치기/접기, 저장 지원',
+      states: ['treeSpinning', 'treeData', 'expandedKeys', 'saveRequestValues', 'isDirty', 'flexGrow'],
+      actions: ['callTreeApi', 'callTreeSaveApi', 'callFormSaveApi', 'setExpandedKeys'],
+      useCases: ['카테고리 관리', '메뉴 관리', '조직도'],
+    },
+    {
+      type: 4,
+      name: '대시보드',
+      description: '여러 개의 리스트와 요약 정보, 탭 전환',
+      states: ['summaryData', 'summarySpinning', 'list01Data', 'list02Data', 'activeTabKey'],
+      actions: ['callSummaryApi', 'callList01Api', 'callList02Api', 'setActiveTabKey'],
+      useCases: ['회원 대시보드', '주문 대시보드', '매출 대시보드'],
+    },
+    {
+      type: 5,
+      name: '단순 리스트',
+      description: '최소한의 기능만 있는 단순 리스트',
+      states: ['listSpinning', 'listData', 'listPage'],
+      actions: ['callListApi', 'changeListPage'],
+      useCases: ['참조 데이터 조회', '드롭다운 목록'],
+    },
+    {
+      type: 6,
+      name: '재정렬 가능 리스트',
+      description: '드래그 앤 드롭으로 순서 변경 가능',
+      states: ['listSpinning', 'listData', 'isReordered'],
+      actions: ['callListApi', 'setListData'],
+      useCases: ['팝업 메뉴', '배너 순서', '메뉴 순서'],
+    },
+    {
+      type: 7,
+      name: '마스터-디테일 + 모달 + 삭제 + 엑셀',
+      description: '왼쪽 리스트, 오른쪽 상세, 모달, 삭제, 엑셀 다운로드',
+      states: ['listSpinning', 'listData', 'listPage', 'selectedItem', 'detail', 'detailSpinning', 'modalOpen', 'deleteSpinning', 'saveSpinning', 'excelSpinning', 'checkedRowKeys'],
+      actions: ['callListApi', 'callExcelDownloadApi', 'callDeleteApi', 'callSaveApi', 'changeListPage', 'setSelectedItem', 'setDetail', 'setModalOpen', 'setCheckedRowKeys'],
+      useCases: ['B2B 견적 상담', '상담 관리', '주문 관리'],
+    },
+    {
+      type: 8,
+      name: '리스트 + 선택 + 엑셀 다운로드',
+      description: '선택 아이템, 체크박스, 엑셀 다운로드 (상세 없음)',
+      states: ['listSpinning', 'listData', 'listPage', 'selectedItem', 'checkedRowKeys', 'listSelectedRowKey', 'listCheckedIndexes', 'orderDetailId'],
+      actions: ['callListApi', 'changeListPage', 'setSelectedItem', 'setCheckedRowKeys', 'setListSelectedRowKey', 'setListCheckedIndexes', 'setOrderDetailId', 'downloadExcel'],
+      useCases: ['주문 전체 조회', '결제 조회', '배송 조회'],
+    },
+    {
+      type: 9,
+      name: '마스터-디테일 + 모달 + 상세조회 API',
+      description: '왼쪽 리스트, 오른쪽 상세, 모달, 상세 조회 API 호출',
+      states: ['listSpinning', 'listData', 'listPage', 'selectedItem', 'detail', 'modalOpen', 'detailSpinning'],
+      actions: ['callListApi', 'changeListPage', 'setSelectedItem', 'setModalOpen', 'setDetail', 'callDetailApi'],
+      useCases: ['직배송 구독', '상담 내역', '주문 상세'],
+    },
+    {
+      type: 10,
+      name: '마스터-디테일 + 엑셀 다운로드',
+      description: '선택된 행 표시, 엑셀 다운로드 (상세/모달 없음)',
+      states: ['listSpinning', 'excelSpinning', 'listData', 'listPage', 'listSelectedRowKey'],
+      actions: ['callListApi', 'callExcelDownloadApi', 'changeListPage', 'setListSelectedRowKey'],
+      useCases: ['상품 그룹 마스터', '분류 관리', '카테고리 마스터'],
+    },
+  ];
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(
+          {
+            success: true,
+            templates,
+            count: templates.length,
+          },
+          null,
+          2
+        ),
+      },
+    ],
+  };
+}

package/src/handlers/scan-metadata.ts

@@ -0,0 +1,485 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+
+/**
+ * 메타데이터 스캔 MCP 툴
+ * 프로젝트의 DTO, Repository, Code, Modal 등을 스캔하여 캐시 생성
+ */
+
+// ========== 타입 정의 ==========
+
+interface DtoField {
+  name: string;
+  type: string;
+  isOptional: boolean;
+  comment?: string;
+  source?: string;  // 필드가 정의된 위치 (예: "MemberSearch", "DefaultDto")
+}
+
+interface DtoIndex {
+  name: string;
+  filePath: string;
+  isExport: boolean;
+  extends?: string[];  // 상속 체인
+  fields: DtoField[];
+}
+
+interface RepositoryMethod {
+  name: string;
+  requestType?: string;
+  responseType?: string;
+}
+
+interface RepositoryInfo {
+  name: string;
+  filePath: string;
+  methods: RepositoryMethod[];
+}
+
+interface CodeInfo {
+  name: string;
+  options: Array<{ label: string; value: string }>;
+}
+
+interface ModalFunction {
+  name: string;  // 예: openCustomerModal
+  filePath: string;
+  returnType?: string;
+}
+
+interface MetadataCache {
+  version: string;
+  scannedAt: string;
+  projectRoot: string;
+  dtos: Record<string, DtoIndex>;
+  repositories: Record<string, RepositoryInfo>;
+  codes: Record<string, CodeInfo>;
+  modals: Record<string, ModalFunction>;
+}
+
+interface ScanMetadataParams {
+  projectRoot: string;
+  forceRescan?: boolean;
+}
+
+// ========== 스캔 경로 패턴 ==========
+
+const DTO_PATTERNS = [
+  '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',
+];
+
+const REPOSITORY_PATTERNS = [
+  'src/services/**/*Repository.ts',
+  'src/services/**/repository/*.ts',
+];
+
+const CODE_PATTERNS = [
+  'src/stores/**/*.ts',
+  'src/**/useCodeStore.ts',
+];
+
+const MODAL_PATTERNS = [
+  'src/modals/**/*Modal.ts',
+  'src/components/**/*Modal.ts',
+];
+
+// ========== 메인 함수 ==========
+
+export async function scanMetadata(args: ScanMetadataParams): Promise<{
+  content: Array<{ type: string; text: string }>;
+}> {
+  const { projectRoot, forceRescan = false } = args;
+
+  // 캐시 파일 경로 (.claude 폴더 사용)
+  const cachePath = path.join(projectRoot, '.claude', 'mcp-cache', 'search-params-meta.json');
+
+  // 캐시 확인
+  if (!forceRescan) {
+    try {
+      const cacheExists = await fs.access(cachePath).then(() => true).catch(() => false);
+      if (cacheExists) {
+        const cacheContent = await fs.readFile(cachePath, 'utf-8');
+        const cache: MetadataCache = JSON.parse(cacheContent);
+
+        // 캐시 유효성 확인 (1시간 이내)
+        const cacheAge = Date.now() - new Date(cache.scannedAt).getTime();
+        if (cacheAge < 60 * 60 * 1000) {
+          return {
+            content: [
+              { type: 'text', text: JSON.stringify({ success: true, cached: true, cache }, null, 2) },
+            ],
+          };
+        }
+      }
+    } catch {
+      // 캐시 없음 or 실패 → 계속 진행
+    }
+  }
+
+  // 메타데이터 스캔
+  console.error(`[MCP] 스캔 시작: ${projectRoot}`);
+
+  const cache: MetadataCache = {
+    version: '1.0.0',
+    scannedAt: new Date().toISOString(),
+    projectRoot,
+    dtos: {},
+    repositories: {},
+    codes: {},
+    modals: {},
+  };
+
+  // 1. DTO 스캔
+  await scanDtos(projectRoot, cache);
+
+  // 2. Repository 스캔
+  await scanRepositories(projectRoot, cache);
+
+  // 3. Code Store 스캔
+  await scanCodes(projectRoot, cache);
+
+  // 4. Modal 함수 스캔
+  await scanModals(projectRoot, cache);
+
+  // extends 체인 해결
+  await resolveExtendsChains(cache);
+
+  // 캐시 저장
+  const cacheDir = path.dirname(cachePath);
+  await fs.mkdir(cacheDir, { recursive: true });
+  await fs.writeFile(cachePath, JSON.stringify(cache, null, 2), 'utf-8');
+
+  // README 생성
+  const readmePath = path.join(cacheDir, 'README.md');
+  await fs.writeFile(
+    readmePath,
+    `# MCP Cache\n\n이 폴더는 MCP 툴이 생성한 메타데이터 캐시입니다.\n\n- search-params-meta.json: DTO, Repository, Code, Modal 메타데이터\n`,
+    'utf-8'
+  );
+
+  console.error(`[MCP] 스캔 완료:`);
+  console.error(`  - DTO: ${Object.keys(cache.dtos).length}개`);
+  console.error(`  - Repository: ${Object.keys(cache.repositories).length}개`);
+  console.error(`  - Code: ${Object.keys(cache.codes).length}개`);
+  console.error(`  - Modal: ${Object.keys(cache.modals).length}개`);
+
+  return {
+    content: [
+      { type: 'text', text: JSON.stringify({ success: true, cached: false, cache }, null, 2) },
+    ],
+  };
+}
+
+// ========== DTO 스캔 ==========
+
+async function scanDtos(projectRoot: string, cache: MetadataCache): Promise<void> {
+  for (const pattern of DTO_PATTERNS) {
+    const files = await glob(pattern, { cwd: projectRoot, absolute: true });
+
+    for (const filePath of files) {
+      try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const dtos = parseDtoFile(content, filePath);
+
+        for (const dto of dtos) {
+          cache.dtos[dto.name] = dto;
+        }
+      } catch (e) {
+        console.error(`[MCP] DTO 스캔 실패: ${filePath}`, e);
+      }
+    }
+  }
+}
+
+function parseDtoFile(content: string, filePath: string): DtoIndex[] {
+  const results: DtoIndex[] = [];
+
+  // 인터페이스 선언 추출 (export interface Name extends... { ... })
+  const interfaceRegex = /export\s+interface\s+(\w+)\s*(?:extends\s+([^{]+))?\s*\{([\s\S]*?)\n\}/g;
+
+  let match;
+  while ((match = interfaceRegex.exec(content)) !== null) {
+    const [, name, extendsClause, body] = match;
+
+    // extends 파싱
+    const extendsList: string[] = [];
+    if (extendsClause && extendsClause.trim()) {
+      // "A, B, C" → ["A", "B", "C"]
+      const types = extendsClause.split(',').map(e => e.trim()).filter(e => e);
+      // 제네릭 제거 (예: DataGridPageResponse<...> → DataGridPageResponse)
+      extendsList.push(...types.map(t => t.replace(/<[^>]+>/, '')));
+    }
+
+    // 필드 파싱
+    const fields = parseFields(body, name);
+
+    results.push({
+      name,
+      filePath,
+      isExport: true,
+      extends: extendsList.length > 0 ? extendsList : undefined,
+      fields,
+    });
+  }
+
+  return results;
+}
+
+function parseFields(body: string, interfaceName: string): DtoField[] {
+  const fields: DtoField[] = [];
+
+  // 필드 추출 (주석 포함)
+  const lines = body.split('\n');
+  let lastComment: string | undefined;
+
+  for (const line of lines) {
+    // 주석 추출
+    const commentMatch = line.match(/^\s*\/\/\s*(.+)$/);
+    if (commentMatch) {
+      lastComment = commentMatch[1].trim();
+      continue;
+    }
+
+    // 필드 추출
+    const fieldMatch = line.match(/^\s*(\w+)\s*(\?)?\s*:\s*([^;]+);/);
+    if (fieldMatch) {
+      const [, name, optional, type] = fieldMatch;
+
+      // 페이징 필드 제외 (pageNumber, pageSize는 SearchParams에서 자동 처리)
+      if (name === 'pageNumber' || name === 'pageSize') {
+        continue;
+      }
+
+      fields.push({
+        name,
+        type: type.trim(),
+        isOptional: optional === '?',
+        comment: lastComment,
+        source: interfaceName,
+      });
+
+      lastComment = undefined;
+    }
+  }
+
+  return fields;
+}
+
+// ========== Repository 스캔 ==========
+
+async function scanRepositories(projectRoot: string, cache: MetadataCache): Promise<void> {
+  for (const pattern of REPOSITORY_PATTERNS) {
+    const files = await glob(pattern, { cwd: projectRoot, absolute: true });
+
+    for (const filePath of files) {
+      try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const repo = parseRepositoryFile(content, filePath);
+
+        if (repo) {
+          cache.repositories[repo.name] = repo;
+        }
+      } catch (e) {
+        console.error(`[MCP] Repository 스캔 실패: ${filePath}`, e);
+      }
+    }
+  }
+}
+
+function parseRepositoryFile(content: string, filePath: string): RepositoryInfo | null {
+  // 클래스 이름 추출
+  const classMatch = content.match(/export\s+class\s+(\w+)Repository/);
+  if (!classMatch) return null;
+
+  const name = classMatch[1] + 'Repository';
+  const methods: RepositoryMethod[] = [];
+
+  // 메서드 추출
+  // 예: async postMemberListMember(params: PostMemberListMemberRequest, config?: ApiRequestConfig)
+  const methodRegex = /async\s+(\w+)\s*\(\s*params:\s*(\w+Request)[^)]*\)/g;
+
+  let match;
+  while ((match = methodRegex.exec(content)) !== null) {
+    const [, methodName, requestType] = match;
+
+    // Response 타입 추출 (시도)
+    const responseMatch = content.match(
+      new RegExp(`${methodName}[^{]*{[^}]*_apiWrapper<(${methodName}Response)>`)
+    );
+
+    methods.push({
+      name: methodName,
+      requestType,
+      responseType: responseMatch?.[1],
+    });
+  }
+
+  return {
+    name,
+    filePath,
+    methods,
+  };
+}
+
+// ========== Code Store 스캔 ==========
+
+async function scanCodes(projectRoot: string, cache: MetadataCache): Promise<void> {
+  for (const pattern of CODE_PATTERNS) {
+    const files = await glob(pattern, { cwd: projectRoot, absolute: true });
+
+    for (const filePath of files) {
+      try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const codes = parseCodeFile(content, filePath);
+
+        for (const code of codes) {
+          cache.codes[code.name] = code;
+        }
+      } catch (e) {
+        // 무시
+      }
+    }
+  }
+}
+
+function parseCodeFile(content: string, filePath: string): CodeInfo[] {
+  const results: CodeInfo[] = [];
+
+  // Code Store 패턴: STATUS_CD: { options: [...] }
+  const codeRegex = /(\w+):\s*\{[^}]*options:\s*\[([\s\S]*?)\]/g;
+
+  let match;
+  while ((match = codeRegex.exec(content)) !== null) {
+    const [, name, optionsStr] = match;
+
+    // options 배열 파싱
+    const options: Array<{ label: string; value: string }> = [];
+    const optionRegex = /\{\s*label:\s*["']([^"']+)["']\s*,\s*value:\s*["']([^"']+)["']\s*\}/g;
+
+    let optMatch;
+    while ((optMatch = optionRegex.exec(optionsStr)) !== null) {
+      options.push({
+        label: optMatch[1],
+        value: optMatch[2],
+      });
+    }
+
+    if (options.length > 0) {
+      results.push({ name, options });
+    }
+  }
+
+  return results;
+}
+
+// ========== Modal 함수 스캔 ==========
+
+async function scanModals(projectRoot: string, cache: MetadataCache): Promise<void> {
+  for (const pattern of MODAL_PATTERNS) {
+    const files = await glob(pattern, { cwd: projectRoot, absolute: true });
+
+    for (const filePath of files) {
+      try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const modals = parseModalFile(content, filePath);
+
+        for (const modal of modals) {
+          cache.modals[modal.name] = modal;
+        }
+      } catch (e) {
+        // 무시
+      }
+    }
+  }
+}
+
+function parseModalFile(content: string, filePath: string): ModalFunction[] {
+  const results: ModalFunction[] = [];
+
+  // openXxxModal 함수 추출
+  // 예: export const openCustomerModal = async (): Promise<CustomerModalResult> =>
+  const modalRegex = /export\s+(const|async\s+function)\s+(open\w+Modal)\s*(?:=\s*async\s*\([^)]*\)\s*:\s*Promise\s*<\s*(\w+)\s*>|\([^)]*\)\s*\{)/g;
+
+  let match;
+  while ((match = modalRegex.exec(content)) !== null) {
+    const [, , funcName, returnType] = match;
+
+    results.push({
+      name: funcName,
+      filePath,
+      returnType,
+    });
+  }
+
+  return results;
+}
+
+// ========== extends 체인 해결 ==========
+
+async function resolveExtendsChains(cache: MetadataCache): Promise<void> {
+  const visited = new Set<string>();
+
+  for (const dtoName of Object.keys(cache.dtos)) {
+    const resolved = await resolveExtendsChain(dtoName, cache, visited);
+    cache.dtos[dtoName] = resolved;
+  }
+}
+
+async function resolveExtendsChain(
+  interfaceName: string,
+  cache: MetadataCache,
+  visited: Set<string>
+): Promise<DtoIndex> {
+  // 순환 참조 방지
+  if (visited.has(interfaceName)) {
+    return { name: interfaceName, filePath: '', isExport: true, fields: [] };
+  }
+  visited.add(interfaceName);
+
+  const current = cache.dtos[interfaceName];
+  if (!current) {
+    return { name: interfaceName, filePath: '', isExport: true, fields: [] };
+  }
+
+  // extends가 없으면 그대로 반환
+  if (!current.extends || current.extends.length === 0) {
+    return current;
+  }
+
+  // 자체 필드 (직접 정의된 필드)
+  const ownFields = current.fields.filter(f => f.source === current.name);
+
+  // 부모 필드 수집
+  const allFields = [...ownFields];
+  const extendsChain: string[] = [];
+
+  for (const parentName of current.extends) {
+    extendsChain.push(parentName);
+
+    const parent = await resolveExtendsChain(parentName, cache, new Set(visited));
+    allFields.push(...parent.fields);
+
+    if (parent.extends) {
+      extendsChain.push(...parent.extends);
+    }
+  }
+
+  // 필드 중복 제거 (하위 클래스가 우선)
+  const uniqueFields = Array.from(
+    new Map(allFields.map(f => [f.name, f])).values()
+  );
+
+  return {
+    ...current,
+    extends: [...new Set(extendsChain)],
+    fields: uniqueFields,
+  };
+}