@axboot-mcp/mcp-server 1.0.0

package/src/handlers/generate-multi-stores.ts

@@ -0,0 +1,577 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { analyzeInterface, InterfaceAnalysis } from './analyze.js';
+import { unifiedTemplate, TemplateVariables } from '../templates/index.js';
+import { buildTemplateVariables } from './generate.js';
+
+/**
+ * PascalCase 변환
+ */
+export function toPascalCase(str: string): string {
+  return str.replace(/(^|-)(\w)/g, (_, __, char) => char.toUpperCase());
+}
+
+/**
+ * camelCase 변환
+ */
+export function toCamelCase(str: string): string {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
+/**
+ * 리스트 그룹 정보
+ */
+export interface ListGroup {
+  name: string;           // 변수명용 (예: "mainList")
+  description: string;    // 설명 (예: "메인 목록")
+  features: string[];     // 필요한 피처
+  hasSearch?: boolean;    // 검색 기능
+  hasExcel?: boolean;     // 엑셀 다운로드
+  hasCheckbox?: boolean;  // 체크박스
+  methodName?: string;    // 매핑할 메서드 이름
+  requestType?: string;   // Request 타입
+  responseType?: string;  // Response 타입
+  dtoType?: string;       // DTO 타입
+  dtoFields?: string[];   // DTO 필드 목록
+}
+
+/**
+ * 다중 리스트 패턴 분석 결과
+ */
+export interface MultiListPattern {
+  isMultiList: boolean;
+  listGroups: ListGroup[];
+  baseStoreName: string;
+  // 추가 피처 감지
+  hasForm?: boolean;
+  hasTab?: boolean;
+  hasAutoLoad?: boolean;  // 선택 시 자동 로드
+}
+
+/**
+ * 다중 리스트 패턴 감지
+ */
+export function detectMultiListPattern(requirements: string): MultiListPattern | null {
+  const lowerReq = requirements.toLowerCase();
+
+  // 다중 리스트 키워드 감지
+  const detectedGroups: ListGroup[] = [];
+
+  // 위치 기반 그룹 감지
+  const locationPatterns = [
+    { pattern: /왼쪽.*목록|메인.*목록|주.*목록|main.*list|master.*list|list.*list/gi, name: 'list', desc: '메인 목록' },
+    { pattern: /상단.*목록|상위.*목록|top.*list/gi, name: 'topList', desc: '상단 목록' },
+    { pattern: /하단.*목록|하위.*목록|bottom.*list/gi, name: 'bottomList', desc: '하단 목록' },
+    { pattern: /오른쪽.*목록|right.*list|detail.*list|sub.*list/gi, name: 'subList', desc: '서브 목록' },
+  ];
+
+  for (const { pattern, name, desc } of locationPatterns) {
+    if (pattern.test(lowerReq)) {
+      detectedGroups.push({
+        name,
+        description: desc,
+        features: ['LIST'],
+      });
+    }
+  }
+
+  // 2개 이상 감지되면 다중 리스트 패턴
+  if (detectedGroups.length >= 2) {
+    const pattern: MultiListPattern = {
+      isMultiList: true,
+      listGroups: detectedGroups,
+      baseStoreName: extractBaseStoreName(requirements),
+    };
+
+    // 추가 피처 감지
+    pattern.hasForm = /폼|form|저장|수정|등록|save|edit|create/gi.test(lowerReq);
+    pattern.hasTab = /탭|tab|tabbed/gi.test(lowerReq);
+    pattern.hasAutoLoad = /선택.*시.*로드|자동.*로드|auto.*load/gi.test(lowerReq);
+
+    return pattern;
+  }
+
+  // 또는 "각 목록", "모든 목록" 같은 표현으로 다중 판단
+  if (/각\s*목록|모든\s*목록|각각의\s*목록/.test(lowerReq)) {
+    const pattern: MultiListPattern = {
+      isMultiList: true,
+      listGroups: [
+        { name: 'list', description: '메인 목록', features: ['LIST'] },
+        { name: 'subList', description: '서브 목록', features: ['LIST'] },
+      ],
+      baseStoreName: extractBaseStoreName(requirements),
+    };
+
+    pattern.hasForm = /폼|form|저장|수정|등록|save|edit|create/gi.test(lowerReq);
+    pattern.hasTab = /탭|tab|tabbed/gi.test(lowerReq);
+    pattern.hasAutoLoad = /선택.*시.*로드|자동.*로드|auto.*load/gi.test(lowerReq);
+
+    return pattern;
+  }
+
+  return null;
+}
+
+/**
+ * 각 그룹별 피처 추출
+ */
+function extractGroupFeatures(pattern: MultiListPattern, requirements: string): MultiListPattern {
+  const lowerReq = requirements.toLowerCase();
+
+  // 공통 기능
+  const hasSearch = lowerReq.includes('검색') || lowerReq.includes('찾기');
+  const hasExcel = lowerReq.includes('엑셀') || lowerReq.includes('excel');
+  const hasCheckbox = lowerReq.includes('체크') || lowerReq.includes('checkbox');
+  const hasPaging = lowerReq.includes('페이징') || lowerReq.includes('pagination');
+
+  for (const group of pattern.listGroups) {
+    group.features = ['LIST'];
+
+    if (hasSearch) {
+      group.features.push('SEARCH');
+      group.hasSearch = true;
+    }
+    if (hasExcel) {
+      group.features.push('EXCEL_DOWNLOAD');
+      group.hasExcel = true;
+    }
+    if (hasCheckbox) {
+      group.features.push('CHECKBOX');
+      group.hasCheckbox = true;
+    }
+    if (hasPaging) {
+      group.features.push('PAGING');
+    }
+  }
+
+  return pattern;
+}
+
+/**
+ * Store 이름 추출
+ */
+function extractBaseStoreName(requirements: string): string {
+  const match = requirements.match(/(\w+)Repository/i);
+  if (match) {
+    return match[1];
+  }
+  return 'MultiList';
+}
+
+/**
+ * 프로젝트 루트 경로 찾기
+ */
+async function findProjectRoot(startPath: string): Promise<string> {
+  let currentPath = startPath;
+
+  while (currentPath !== path.parse(currentPath).root) {
+    const packageJsonPath = path.join(currentPath, 'package.json');
+    try {
+      await fs.access(packageJsonPath);
+      return currentPath;
+    } catch {
+      currentPath = path.dirname(currentPath);
+    }
+  }
+
+  throw new Error('프로젝트 루트를 찾을 수 없습니다');
+}
+
+/**
+ * DTO 파일 경로 찾기
+ */
+async function findDtoFile(projectRoot: string, dtoName: string): Promise<string | null> {
+  const dtoPaths = [
+    path.join(projectRoot, 'src/services/@interface/dto', `${dtoName}.ts`),
+    path.join(projectRoot, 'src/services/@interface/dto', dtoName, 'index.ts'),
+  ];
+
+  for (const dtoPath of dtoPaths) {
+    try {
+      await fs.access(dtoPath);
+      return dtoPath;
+    } catch {
+      continue;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * DTO 파일에서 필드 추출
+ */
+async function extractDtoFields(dtoFilePath: string): Promise<string[]> {
+  try {
+    const content = await fs.readFile(dtoFilePath, 'utf-8');
+    const fields: string[] = [];
+
+    // 인터페이스 정의 찾기
+    const interfaceMatch = content.match(/export\s+interface\s+\w+\s+extends\s+\w+\s*{([^}]+)}/s);
+    if (!interfaceMatch) {
+      return [];
+    }
+
+    const interfaceBody = interfaceMatch[1];
+
+    // 필드 추출 (optional 체이닝 ?, readonly, 주석 제외)
+    const fieldRegex = /(?:readonly\s+)?(\w+)\??:\s*(?:(?:{[^}]*})|(?:[^,{\n]+))/g;
+    let match;
+
+    while ((match = fieldRegex.exec(interfaceBody)) !== null) {
+      const fieldName = match[1];
+      // 메서드 제외
+      if (!fieldName.includes('(') && fieldName !== 'rowId' && fieldName !== '__status__') {
+        fields.push(fieldName);
+      }
+    }
+
+    return fields;
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * DTO의 기본값 생성 (실제 DTO 파일 파싱)
+ */
+async function getDtoFieldsWithDefaults(
+  projectRoot: string,
+  dtoType: string
+): Promise<{ fields: string[]; defaults: string }> {
+  try {
+    const dtoFilePath = await findDtoFile(projectRoot, dtoType);
+
+    if (dtoFilePath) {
+      const fields = await extractDtoFields(dtoFilePath);
+
+      if (fields.length > 0) {
+        // 기본값 생성 (문자열 필드는 빈 문자열, 선택적 필드는 undefined)
+        const defaultEntries = fields
+          .filter(f => !f.endsWith('?'))  // required 필드만
+          .map(f => `${f}: ""`)
+          .join(', ');
+
+        return {
+          fields,
+          defaults: defaultEntries || '{ /* DTO fields */ }',
+        };
+      }
+    }
+  } catch (error) {
+    // 파싱 실패 시 기본값 사용
+  }
+
+  // 파싱 실패 또는 파일을 찾지 못한 경우
+  const fallbackFields = [`${dtoType.toLowerCase()}Cd: ''`, `${dtoType.toLowerCase()}Nm: ''`];
+  return {
+    fields: fallbackFields.map(f => f.split(':')[0]),
+    defaults: fallbackFields.join(', '),
+  };
+}
+
+/**
+ * 통합 다중 리스트 Store 생성
+ */
+export async function generateMultiStores(args: {
+  interfacePath: string;
+  outputPath: string;
+  requirements: string;
+  baseStoreName: string;
+}): Promise<{
+  content: Array<{ type: string; text: string }>;
+}> {
+  const { interfacePath, outputPath, requirements, baseStoreName } = args;
+
+  try {
+    // 1. 프로젝트 루트 경로 찾기
+    const projectRoot = await findProjectRoot(path.dirname(interfacePath));
+
+    // 2. 인터페이스 분석
+    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 || '인터페이스 분석 실패',
+            }),
+          },
+        ],
+      };
+    }
+
+    // 3. 다중 리스트 패턴 감지
+    let pattern = detectMultiListPattern(requirements);
+    if (!pattern || !pattern.isMultiList) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              success: false,
+              error: '다중 리스트 패턴을 감지하지 못했습니다',
+            }),
+          },
+        ],
+      };
+    }
+
+    // 4. 피처 추출
+    pattern = extractGroupFeatures(pattern, requirements);
+
+    // 5. Store 이름 설정 (사용자가 제시한 파일명 사용)
+    const storeName = baseStoreName;
+    const storeInterface = baseStoreName
+      .replace(/^use/, '')
+      .replace(/Store$/, '')
+      .toLowerCase() + 'Store';
+
+    // 6. Service 정보 및 메서드 매핑
+    const serviceName = analyzeData.serviceName || 'UnknownService';
+    const methods = analyzeData.methods || [];
+    const listMethods = methods.filter((m: any) => m.isListMethod);
+
+    // 스마트 메서드 매핑 - 그룹과 메서드 이름의 키워드를 매칭
+    const usedMethodIndices = new Set<number>();
+
+    for (const group of pattern.listGroups) {
+      const groupName = group.name.toLowerCase();
+      const groupDesc = group.description.toLowerCase();
+
+      // 그룹 이름/설명과 메서드 이름의 키워드 매칭
+      let bestMatchIndex = -1;
+      let bestMatchScore = 0;
+
+      listMethods.forEach((method: any, index: number) => {
+        if (usedMethodIndices.has(index)) return;
+
+        const methodName = method.name.toLowerCase();
+        let score = 0;
+
+        if (groupName.includes('list') || groupDesc.includes('메인') || groupDesc.includes('왼쪽') || groupDesc.includes('left')) {
+          if (methodName.includes('group') || methodName.includes('master') || methodName.includes('main')) {
+            score = 10;
+          } else if (methodName.includes('list')) {
+            score = 5;
+          }
+        } else if (groupName.includes('sub') || groupDesc.includes('서브') || groupDesc.includes('오른쪽') || groupDesc.includes('right') || groupDesc.includes('detail')) {
+          if (methodName.includes('list') && !methodName.includes('group')) {
+            score = 10;
+          } else if (methodName.includes('detail') || methodName.includes('child')) {
+            score = 8;
+          }
+        }
+
+        if (score > bestMatchScore) {
+          bestMatchScore = score;
+          bestMatchIndex = index;
+        }
+      });
+
+      let targetIndex = bestMatchIndex;
+      if (targetIndex === -1) {
+        for (let i = 0; i < listMethods.length; i++) {
+          if (!usedMethodIndices.has(i)) {
+            targetIndex = i;
+            break;
+          }
+        }
+      }
+
+      if (targetIndex !== -1 && targetIndex < listMethods.length) {
+        const method = listMethods[targetIndex];
+        group.methodName = method.name;
+        group.requestType = method.requestType || 'any';
+        group.responseType = method.responseType || 'any';
+
+        // DTO 타입 추출
+        if (method.responseType) {
+          group.dtoType = extractDtoType(method.responseType);
+
+          // 실제 DTO 필드 파싱
+          const dtoInfo = await getDtoFieldsWithDefaults(projectRoot, group.dtoType);
+          group.dtoFields = dtoInfo.fields;
+        }
+
+        usedMethodIndices.add(targetIndex);
+      } else {
+        if (listMethods.length > 0) {
+          const method = listMethods[0];
+          group.methodName = method.name;
+          group.requestType = method.requestType || 'any';
+          group.responseType = method.responseType || 'any';
+        }
+      }
+    }
+
+    // 7. 템플릿 변수 빌드 (기본 변수)
+    const baseVariables = buildTemplateVariables(analyzeData, 1, storeName);
+
+    // 8. 다중 리스트용 변수 추가
+    const mainGroup = pattern.listGroups[0];
+    const subGroup = pattern.listGroups[1];
+
+    const multiListVariables: Partial<TemplateVariables> = {
+      HAS_MULTI_LIST: true,
+      SUB_LIST_DTO_ITEM: subGroup.dtoType || 'any',
+      SUB_LIST_METHOD_NAME: toCamelCase(subGroup.methodName || ''),
+      SUB_LIST_REQUEST_EXTENDS: subGroup.requestType && subGroup.requestType !== 'any'
+        ? `extends ${subGroup.requestType}`
+        : '',
+      SUB_LIST_RESPONSE_FIELD: 'ds',
+      IS_SUB_LIST_PARENT_KEY: true,
+      PARENT_KEY_FIELD: getParentKeyField(mainGroup.dtoType || ''),
+      HAS_SUB_LIST_CHECKBOX: subGroup.hasCheckbox || false,
+      HAS_FORM: pattern.hasForm || false,
+      HAS_AUTO_LOAD: pattern.hasAutoLoad || false,
+      SUB_LIST_REQUIRED_FIELDS_DEFAULTS: generateRequiredFieldsDefaults(subGroup.dtoFields || []),
+    };
+
+    // 9. 변수 병합
+    const variables: TemplateVariables = {
+      ...baseVariables,
+      ...multiListVariables,
+    };
+
+    // 10. 템플릿 적용
+    const storeCode = applyTemplate(unifiedTemplate, variables);
+
+    // 8. 파일 생성
+    const outputDir = path.dirname(outputPath);
+    await fs.mkdir(outputDir, { recursive: true });
+    await fs.writeFile(outputPath, storeCode, 'utf-8');
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(
+            {
+              success: true,
+              message: `${pattern.listGroups.length}개의 리스트를 통합한 Store를 생성했습니다`,
+              outputPath,
+              requirements,
+              pattern: {
+                listGroups: pattern.listGroups.map((g) => ({
+                  name: g.name,
+                  description: g.description,
+                  features: g.features,
+                  dtoType: g.dtoType,
+                })),
+                hasForm: pattern.hasForm,
+                hasTab: pattern.hasTab,
+                hasAutoLoad: pattern.hasAutoLoad,
+              },
+              storeName,
+              analysis: {
+                serviceName,
+                methodCount: analyzeData.methods.length,
+              },
+            },
+            null,
+            2
+          ),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+          }),
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * DTO 타입 추출
+ */
+function extractDtoType(responseType: string): string {
+  // GetCodeGroupListResponse → CodeGroup
+  // GetCodeListResponse → Code
+  if (responseType.endsWith('Response')) {
+    const baseName = responseType.slice(0, -8); // Remove 'Response'
+    // GetCodeGroupList → CodeGroup
+    if (baseName.startsWith('Get')) {
+      const withoutGet = baseName.slice(3); // CodeGroupList
+      if (withoutGet.endsWith('List')) {
+        return withoutGet.slice(0, -4); // CodeGroup
+      }
+      return withoutGet;
+    }
+    return baseName;
+  }
+  return responseType;
+}
+
+/**
+ * 템플릿 적용 - Mustache.js 사용
+ */
+function applyTemplate(template: string, variables: Record<string, any>): string {
+  const Mustache = require('mustache');
+
+  // TypeScript 코드 생성이므로 HTML 이스케이프 비활성화
+  const originalEscape = Mustache.escape;
+  Mustache.escape = (text: any) => String(text);
+
+  try {
+    let result = Mustache.render(template, variables);
+
+    // 후처리: 빈 줄 제거만 수행 (정규식 제거로 인한 함수 시그니처 손실 방지)
+    result = result
+      // 빈 줄 제거 (연속된 2개 이상의 줄바꿈을 하나로 줄임)
+      .replace(/\n\s*\n\s*\n/g, '\n\n')
+      // 빈 줄 정리
+      .replace(/\n\s*\n/g, '\n');
+
+    return result;
+  } finally {
+    Mustache.escape = originalEscape;
+  }
+}
+
+/**
+ * 상위 키 필드명 추출
+ */
+function getParentKeyField(dtoType: string): string {
+  const lower = dtoType.toLowerCase();
+  if (lower.includes('group')) return 'groupCd';
+  if (lower.includes('category')) return 'categoryCd';
+  if (lower.includes('code')) return 'code';
+  return 'id';
+}
+
+/**
+ * Request 필수 필드 기본값 생성
+ */
+function generateRequiredFieldsDefaults(fields: string[]): string {
+  const lines: string[] = [];
+
+  for (const field of fields) {
+    const lowerField = field.toLowerCase();
+    if (/(Tpcd|tpCd|Code|cd|Type|type)$/.test(field)) {
+      lines.push(`    ${field}: '',`);
+    } else if (/(Yn|yn)$/.test(field)) {
+      lines.push(`    ${field}: '',`);
+    } else if (/(No|Number)$/.test(field)) {
+      lines.push(`    ${field}: '',`);
+    } else if (/(Date|Dt|Dtm)$/.test(field)) {
+      lines.push(`    ${field}: '',`);
+    } else {
+      lines.push(`    ${field}: '',`);
+    }
+  }
+
+  return lines.join('\n');
+}