@axboot-mcp/mcp-server 1.0.0

package/src/handlers/analyze.ts

@@ -0,0 +1,1373 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+
+export interface MethodInfo {
+  name: string;
+  requestType?: string;
+  responseType?: string;
+  isListMethod: boolean;
+  isRequestArray?: boolean; // Request 타입이 배열인지 여부
+  hasPage?: boolean; // 페이징 여부
+  comment?: string; // 메서드 주석 (/* 주석 */ 형태)
+  firstParamName?: string; // 첫 번째 파라미터 이름 (예: id, bbscttNo)
+  responseListField?: string | null; // 리스트 응답 필드명 (ds, list, items 등)
+  responseDetailField?: string | null; // 상세 응답 필드명 (rs, detail 등)
+}
+
+export interface DateRangeField {
+  startField: string; // bgnDtm, startDateTime 등
+  endField: string; // endDtm, endDateTime 등
+  searchType: string; // 'bgnDtm' | 'startDateTime' | 'unknown'
+  hasDayJs: boolean; // dayjs import 필요 여부 (Dt/Dtm 필드가 1개 이상 있는 경우)
+}
+
+// 요청 필드 분류
+export type RequestFieldType =
+  | 'page'          // pageNumber, pageSize
+  | 'dateRange'     // bgnDtm, endDtm 등
+  | 'search'        // searchText, searchKeyword
+  | 'searchType'    // searchType, searchDiv
+  | 'code'          // statusCd, useYn 등 (Code 타입)
+  | 'yn'            // useYn, delYn 등 (Y|N)
+  | 'number'        // 숫자 필드
+  | 'string'        // 문자열 필드
+  | 'unknown';      // 기타
+
+export interface RequestFieldInfo {
+  name: string;           // 필드명
+  type: string;           // 타입 (string, number, Code 등)
+  fieldType: RequestFieldType;  // 필드 분류
+  isOptional: boolean;    // optional 여부 (?)
+  comment?: string;       // 주석
+}
+
+export interface InterfaceAnalysis {
+  success: boolean;
+  filePath: string;
+  className: string;
+  serviceName: string;
+  methods: MethodInfo[];
+  imports: string[]; // import 경로
+  types: string[]; // 타입 이름들
+  dtoTypes: string[];
+  hasPage?: boolean; // 전체 페이징 여부 (Response에 page 필드가 있는지)
+  hasPageInRequest?: boolean; // Request에 pageNumber/pageSize 필드가 있는지 (listRequestValue 초기값 결정용)
+  hasDateRange: boolean; // dateRange 패턴 존재 여부 (쌍이 모두 있는 경우)
+  hasDayJs: boolean; // dayjs import 필요 여부 (Dt/Dtm 필드가 1개 이상 있는 경우)
+  dateRangeFields?: DateRangeField; // dateRange 관련 필드 정보
+  idField?: string; // __status__ 패턴용 ID 필드 (삭제 메서드 Request의 첫 번째 필드)
+  idFieldType?: string; // ID 필드의 실제 타입 (예: 'string', 'number', 'string | undefined')
+  idFieldIsOptional?: boolean; // ID 필드가 optional인지 여부
+  requiredFields?: string[]; // Request 타입의 필수 필드들 (pageNumber, pageSize 제외)
+  hasExcel?: boolean; // 엑셀 다운로드 API 존재 여부
+  hasArrayDeleteApi?: boolean; // 배열 삭제 API 존재 여부 (callMultiDeleteApi 생성 결정용)
+  excelMethodName?: string | null; // 엑셀 메서드 이름
+  excelRequestType?: string; // 엑셀 메서드 Request 타입
+  isExcelRequestArray?: boolean; // 엑셀 메서드 Request가 배열인지 여부
+  // 주석 기반 기능 판단 (더 정확한 판단)
+  hasDeleteFromComment?: boolean; // 주석에서 삭제 판단
+  hasSaveFromComment?: boolean; // 주석에서 저장 판단
+  hasDetailFromComment?: boolean; // 주석에서 상세 판단
+  // 요청 필드 분석
+  requestFields?: RequestFieldInfo[]; // List Request 인터페이스의 필드 정보
+  entityName?: string; // 엔티티명 (예: Banner)
+  isServiceExported?: boolean; // services/index.ts에서 실제 export되었는지 여부
+}
+
+/**
+ * 인터페이스 Repository 파일 분석
+ */
+export async function analyzeInterface(args: { interfacePath: string }) {
+  const { interfacePath } = args;
+
+  // 파일 존재 확인
+  try {
+    await fs.access(interfacePath);
+  } catch {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: `파일을 찾을 수 없습니다: ${interfacePath}`,
+          }),
+        },
+      ],
+    };
+  }
+
+  // Repository 파일 읽기
+  let repositoryContent = await fs.readFile(interfacePath, 'utf-8');
+
+  // 파일 타입 감지 (Interface 파일 vs Repository 파일)
+  const isDirectInterfaceFile = /export\s+abstract\s+class\s+\w+Interface/.test(repositoryContent);
+
+  // Interface 파일 경로 찾기 (import 문에서 추출)
+  let interfaceContent = '';
+  let dtoContent = '';
+
+  // 파일 타입에 따라 다르게 처리
+  let interfaceDir: string;
+  let dtoDir: string;
+
+  if (isDirectInterfaceFile) {
+    // Interface 파일을 직접 전달받은 경우
+    // interfacePath: /path/to/services/@interface/interface/BannerInterface.ts
+    // interfaceDir: /path/to/services/@interface/interface (같은 폴더)
+    // dtoDir: /path/to/services/@interface/dto
+    interfaceDir = path.dirname(interfacePath);
+    dtoDir = path.join(path.dirname(interfaceDir), 'dto');
+    interfaceContent = repositoryContent; // 이미 interface 파일 내용
+  } else {
+    // Repository 파일을 전달받은 경우
+    const interfaceImportMatch = repositoryContent.match(/import\s+{[^}]*}\s+from\s+["']\.\.\/?interface["']/);
+    const repoDir = path.dirname(interfacePath);
+
+    if (interfaceImportMatch) {
+      interfaceDir = path.join(repoDir, '..', 'interface');
+      dtoDir = path.join(repoDir, '..', 'dto');
+
+      const classMatch = repositoryContent.match(/export\s+class\s+(\w+)Repository/);
+      if (classMatch) {
+        const entityName = classMatch[1];
+        const interfaceFilePath = path.join(interfaceDir, `${entityName}Interface.ts`);
+
+        try {
+          await fs.access(interfaceFilePath);
+          interfaceContent = await fs.readFile(interfaceFilePath, 'utf-8');
+        } catch {
+          // Interface 파일이 없으면 기존 방식대로 진행
+        }
+      }
+    } else {
+      // interface import가 없는 경우 기본 경로 설정
+      interfaceDir = repoDir;
+      dtoDir = path.join(repoDir, 'dto');
+    }
+  }
+
+  // dto 폴더의 모든 파일 읽기 (Search DTO 등이 있을 수 있음)
+  try {
+    const dtoFiles = await fs.readdir(dtoDir);
+    for (const file of dtoFiles) {
+      if (file.endsWith('.ts')) {
+        const dtoFilePath = path.join(dtoDir, file);
+        try {
+          const content = await fs.readFile(dtoFilePath, 'utf-8');
+          dtoContent += '\n' + content;
+        } catch {
+          // 파일 읽기 실패 시 무시
+        }
+      }
+    }
+  } catch {
+    // dto 폴더가 없으면 무시
+  }
+
+  // 세 파일 내용을 합쳐서 분석 (Interface + DTO 파일 내용 포함)
+  const combinedContent = repositoryContent + '\n' + interfaceContent + '\n' + dtoContent;
+
+  // services/index.ts 읽기 (실제 export된 Service 이름을 찾기 위해)
+  let servicesIndexContent = '';
+  // services/index.ts 경로 찾기 - 현재 경로에서 상위 폴더로 올라가며 찾기
+  let currentDir = path.dirname(interfacePath);
+  let servicesIndexFound = false;
+
+  // 최대 5번 상위 폴더로 올라가며 services/index.ts 찾기
+  for (let i = 0; i < 5; i++) {
+    const indexPath = path.join(currentDir, 'index.ts');
+    const servicesPath = path.join(currentDir, 'services', 'index.ts');
+
+    try {
+      // 먼저 현재 폴더에 index.ts가 있는지 확인
+      await fs.access(indexPath);
+      const content = await fs.readFile(indexPath, 'utf-8');
+      // Service export 패턴이 있는지 확인
+      if (/export\s+const\s+\w+\s*=\s+new\s+\w+Repository\s*\(/.test(content) ||
+          /export\s+const\s+\w+\s*=\s+new\s+\w+Interface\s*\(/.test(content)) {
+        servicesIndexContent = content;
+        servicesIndexFound = true;
+        break;
+      }
+    } catch {
+      // 현재 폴더에 index.ts가 없거나 Service export 패턴이 없음
+    }
+
+    try {
+      // services 폴더 안에 index.ts가 있는지 확인
+      await fs.access(servicesPath);
+      const content = await fs.readFile(servicesPath, 'utf-8');
+      if (/export\s+const\s+\w+\s*=\s+new\s+\w+Repository\s*\(/.test(content) ||
+          /export\s+const\s+\w+\s*=\s+new\s+\w+Interface\s*\(/.test(content)) {
+        servicesIndexContent = content;
+        servicesIndexFound = true;
+        break;
+      }
+    } catch {
+      // services/index.ts가 없음
+    }
+
+    // 상위 폴더로 이동
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      // 더 이상 상위 폴더가 없음
+      break;
+    }
+    currentDir = parentDir;
+  }
+
+  // 분석 결과 - combinedContent를 전달하여 Response 인터페이스를 찾을 수 있게 함
+  const analysis = parseInterfaceFile(interfacePath, repositoryContent, combinedContent, servicesIndexContent);
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(analysis, null, 2),
+      },
+    ],
+  };
+}
+
+/**
+ * 인터페이스 파일 파싱
+ * @param filePath 파일 경로
+ * @param repoContent Repository 파일 내용 (메서드 추출용)
+ * @param combinedContent Repository + Interface 파일 내용 (Response 인터페이스 추출용)
+ * @param servicesIndexContent services/index.ts 내용 (실제 export된 Service 이름 추출용)
+ */
+function parseInterfaceFile(filePath: string, repoContent: string, combinedContent: string, servicesIndexContent: string): InterfaceAnalysis {
+  const analysis: InterfaceAnalysis = {
+    success: true,
+    filePath,
+    className: '',
+    serviceName: '',
+    methods: [],
+    imports: [],
+    types: [],
+    dtoTypes: [],
+    hasPage: false,
+    hasDateRange: false,
+    hasDayJs: false,
+  };
+
+  // 클래스 이름 추출 (예: MemberRepository 또는 BannerInterface)
+  let classMatch = repoContent.match(/export\s+class\s+(\w+)Repository/);
+  let isInterfaceFile = false;
+
+  if (!classMatch) {
+    // Interface 파일도 지원 (추상 클래스)
+    classMatch = repoContent.match(/export\s+abstract\s+class\s+(\w+)Interface/);
+    if (classMatch) {
+      isInterfaceFile = true;
+    }
+  }
+
+  if (classMatch) {
+    const entityName = classMatch[1];
+    analysis.className = isInterfaceFile ? `${entityName}Interface` : `${entityName}Repository`;
+    analysis.entityName = entityName;
+
+    // services/index.ts에서 실제 export된 Service 이름 찾기
+    // 패턴: export const ServiceName = new EntityRepository(...)
+    if (servicesIndexContent) {
+      // 대소문자 구분 없이 매칭하지만, 실제 export된 이름을 그대로 사용
+      // BannerRepository -> BannerService, BannerSerevice, bannerService 등 모두 매칭
+      const serviceExportPatterns = [
+        new RegExp(`export\\s+const\\s+(\\w+)\\s*=\\s+new\\s+${entityName}Repository\\s*\\(`, 'i'),
+        new RegExp(`export\\s+const\\s+(\\w+)\\s*=\\s+new\\s+${entityName}Interface\\s*\\(`, 'i'),
+      ];
+
+      for (const pattern of serviceExportPatterns) {
+        const match = servicesIndexContent.match(pattern);
+        if (match) {
+          analysis.serviceName = match[1]; // 실제 export된 이름 (대소문자 포함)
+          analysis.isServiceExported = true; // 실제로 export됨을 표시
+          break;
+        }
+      }
+
+      // 못 찾으면 기존 방식대로 추론
+      if (!analysis.serviceName) {
+        analysis.serviceName = `${entityName}Service`;
+        analysis.isServiceExported = false; // export되지 않음
+      }
+    } else {
+      analysis.serviceName = `${entityName}Service`;
+      analysis.isServiceExported = false; // export되지 않음
+    }
+  }
+
+  // Import 경로 추출
+  const importPathSet = new Set<string>();
+  const importMatches = repoContent.matchAll(/import\s+\{[^}]+\}\s+from\s+["']([^"']+)["']/g);
+  for (const match of importMatches) {
+    if (match[1]) {
+      importPathSet.add(match[1]);
+    }
+  }
+  analysis.imports = Array.from(importPathSet);
+
+  // Import 문에서 타입들 추출 (interface import에서)
+  const interfaceImportMatch = repoContent.match(/import\s+\{([^}]+)\}\s+from\s+["'][^"']*interface["']/);
+  const typeSet = new Set<string>();
+
+  if (interfaceImportMatch) {
+    const importTypes = interfaceImportMatch[1].split(',');
+    for (const type of importTypes) {
+      const trimmed = type.trim();
+      // Interface 타입과 배열 타입 제외
+      if (trimmed && !trimmed.endsWith('Interface') && !trimmed.endsWith('[]')) {
+        typeSet.add(trimmed);
+      }
+    }
+  }
+
+  // 메서드에서 사용되는 Response 타입도 추가 (Interface 제외)
+  for (const methodMatch of repoContent.matchAll(/_apiWrapper<([^>]+)>/g)) {
+    const returnType = methodMatch[1];
+    if (returnType && returnType !== 'void' && !returnType.endsWith('Interface')) {
+      // 배열 타입인 경우 비배열 버전 추가
+      if (returnType.endsWith('[]')) {
+        typeSet.add(returnType.slice(0, -2));
+      } else {
+        typeSet.add(returnType);
+      }
+    }
+  }
+
+  analysis.types = Array.from(typeSet);
+
+  // 메서드 추출 (Repository async 메서드 또는 Interface abstract 메서드)
+  // 1단계: Repository 패턴 (async method with body): async methodName(...) { ... }
+  const repoMethodPattern = /async\s+(\w+)\s*\(([^)]*)\)(?:\s*:\s*Promise<([^>]+)>)?\s*\{/g;
+  // 2단계: Interface 패턴 (abstract method with semicolon): abstract methodName(...): Promise<...>;
+  const interfaceMethodPattern = /abstract\s+(\w+)\s*\(([^)]*)\)(?:\s*:\s*Promise<([^>]+)>)?\s*;/g;
+
+  // Repository 패턴 추출
+  let repoMethodMatch;
+  while ((repoMethodMatch = repoMethodPattern.exec(repoContent)) !== null) {
+    const methodName = repoMethodMatch[1];
+    const params = repoMethodMatch[2];
+    const explicitReturnType = repoMethodMatch[3];
+
+    const methodComment = extractMethodComment(repoContent, methodName, repoMethodMatch.index);
+    analysis.methods.push(extractMethodInfo(methodName, params, explicitReturnType, methodComment, repoContent, combinedContent, analysis));
+  }
+
+  // Interface 패턴 추출 (추상 클래스)
+  let interfaceMethodMatch;
+  while ((interfaceMethodMatch = interfaceMethodPattern.exec(repoContent)) !== null) {
+    const methodName = interfaceMethodMatch[1];
+    const params = interfaceMethodMatch[2];
+    const explicitReturnType = interfaceMethodMatch[3];
+
+    const methodComment = extractMethodComment(repoContent, methodName, interfaceMethodMatch.index);
+    analysis.methods.push(extractMethodInfo(methodName, params, explicitReturnType, methodComment, repoContent, combinedContent, analysis));
+  }
+
+  // DTO 타입 추출 (Response에서 ds 타입 찾기) - combinedContent 사용
+  for (const method of analysis.methods) {
+    if (method.responseType) {
+      const dtoType = extractDtoType(combinedContent, method.responseType);
+      // 빈 문자열, unknown, Interface로 끝나는 타입은 제외
+      if (dtoType && dtoType !== 'unknown' && !dtoType.endsWith('Interface') && !analysis.dtoTypes.includes(dtoType)) {
+        analysis.dtoTypes.push(dtoType);
+        // DTO 타입도 import에 추가
+        typeSet.add(dtoType);
+      }
+    }
+  }
+
+  analysis.types = Array.from(typeSet);
+
+  // dateRange/dayjs 패턴 감지 (Request 타입에서 Dt/Dtm 필드 찾기)
+  const selectedMethod = analysis.methods.find(m => m.isListMethod);
+  if (selectedMethod && selectedMethod.requestType) {
+    const dateRangeInfo = detectDateRangePattern(combinedContent, selectedMethod.requestType);
+    if (dateRangeInfo) {
+      analysis.hasDayJs = dateRangeInfo.hasDayJs;
+      analysis.dateRangeFields = dateRangeInfo;
+      // 쌍이 모두 있는 경우에만 hasDateRange를 true로 설정
+      if (dateRangeInfo.startField && dateRangeInfo.endField) {
+        analysis.hasDateRange = true;
+      }
+    }
+  }
+
+  // __status__ 패턴용 ID 필드 추출 (삭제 메서드 Request의 첫 번째 필드)
+  const deleteMethod = analysis.methods.find(m =>
+    m.name.toLowerCase().includes('delete') || m.name.toLowerCase().includes('remove')
+  );
+  if (deleteMethod && deleteMethod.requestType) {
+    const idFieldInfo = extractIdFieldFromRequest(combinedContent, deleteMethod.requestType);
+    analysis.idField = idFieldInfo.fieldName;
+    analysis.idFieldType = idFieldInfo.fieldType;
+    analysis.idFieldIsOptional = idFieldInfo.isOptional;
+  } else if (selectedMethod && selectedMethod.requestType) {
+    // 삭제 메서드가 없으면 리스트 메서드의 Request 타입에서 ID 필드 추출
+    const idFieldInfo = extractIdFieldFromRequest(combinedContent, selectedMethod.requestType);
+    analysis.idField = idFieldInfo.fieldName;
+    analysis.idFieldType = idFieldInfo.fieldType;
+    analysis.idFieldIsOptional = idFieldInfo.isOptional;
+  }
+
+  // Request 타입의 필수 필드 추출 (List 메서드의 Request 타입에서)
+  if (selectedMethod && selectedMethod.requestType) {
+    analysis.requiredFields = extractRequiredFieldsFromRequest(combinedContent, selectedMethod.requestType);
+  }
+
+  // 엔티티명 추출 (예: BannerRepository → Banner)
+  const entityName = analysis.className.replace('Repository', '');
+  analysis.entityName = entityName;
+
+  // 주석 기반 기능 판단 (더 정확한 판단)
+  // 주석에서 "/* 엔티티명 삭제 */", "/* 엔티티명 저장 */" 패턴 찾기
+  for (const method of analysis.methods) {
+    if (method.comment) {
+      const commentLower = method.comment.toLowerCase().replace(/\s+/g, '');
+      // 예: "/* 배너 삭제 */" → "배너삭제"
+      // 삭제/저장/상세 키워드만 확인 (엔티티명 매칭은 복잡하므로 키워드만 사용)
+      if (commentLower.includes('삭제') || commentLower.includes('delete')) {
+        analysis.hasDeleteFromComment = true;
+      }
+      if (commentLower.includes('저장') || commentLower.includes('save') || commentLower.includes('insert') || commentLower.includes('create')) {
+        analysis.hasSaveFromComment = true;
+      }
+      if (commentLower.includes('상세') || commentLower.includes('detail') || commentLower.includes('정보') || commentLower.includes('info') || commentLower.includes('get')) {
+        analysis.hasDetailFromComment = true;
+      }
+    }
+  }
+
+  // 엑셀 다운로드 API 존재 여부 체크
+  // 1. 메서드명에 excel 키워드가 있거나 주석에 엑셀 키워드가 있는 메서드 찾기
+  // 2. 첫 번째 엑셀 API를 사용
+  const excelMethods = analysis.methods.filter(m => {
+    const nameLower = m.name.toLowerCase();
+    const commentLower = (m.comment || '').toLowerCase();
+    // 메서드명에 excel 또는 주석에 엑셀
+    return nameLower.includes('excel') || commentLower.includes('엑셀');
+  });
+
+  if (excelMethods.length > 0) {
+    analysis.hasExcel = true;
+    // 첫 번째 엑셀 메서드 사용
+    analysis.excelMethodName = toCamelCase(excelMethods[0].name);
+    analysis.excelRequestType = excelMethods[0].requestType;
+    analysis.isExcelRequestArray = excelMethods[0].isRequestArray || false;
+  } else {
+    analysis.hasExcel = false;
+    analysis.excelMethodName = null;
+    analysis.excelRequestType = undefined;
+    analysis.isExcelRequestArray = false;
+  }
+
+  // 배열 삭제 API 존재 여부 확인 (callMultiDeleteApi 생성 결정용)
+  // 삭제 메서드가 2개 이상이고, 선택되지 않은 메서드 중 배열이 있으면 true
+  const deleteMethods = analysis.methods.filter(m => {
+    const nameLower = m.name.toLowerCase();
+    const commentLower = (m.comment || '').toLowerCase();
+    return nameLower.includes('delete') || nameLower.includes('remove') || commentLower.includes('삭제');
+  });
+
+  // 삭제 메서드가 2개 이상이고, 그중 배열이 있는지 확인
+  const hasArrayDeleteInOtherMethods = deleteMethods.length >= 2 && deleteMethods.some(m => m.isRequestArray === true);
+  analysis.hasArrayDeleteApi = hasArrayDeleteInOtherMethods;
+
+  // Request에 pageNumber/pageSize 필드가 있는지 확인 (listRequestValue 초기값 결정용)
+  // 선택된 List 메서드의 Request 타입 확인
+  const listMethods = analysis.methods.filter((m) => m.isListMethod);
+  if (listMethods.length > 0 && listMethods[0].requestType) {
+    analysis.hasPageInRequest = hasPageInRequest(combinedContent, listMethods[0].requestType);
+
+    // 요청 필드 분석
+    analysis.requestFields = extractRequestFields(combinedContent, listMethods[0].requestType);
+  } else {
+    analysis.hasPageInRequest = false;
+    analysis.requestFields = [];
+  }
+
+  return analysis;
+}
+
+/**
+ * List 메서드인지 확인
+ * 우선순위:
+ * 1. 주석에 '목록' 키워드 포함 (예: 메뉴 목록, 배너 목록)
+ * 2. '목록'으로 끝나는 메서드 (예: getMember목록)
+ * 3. 'list' 또는 'List'를 포함하는 메서드
+ * 4. 그 외는 List 메서드로 분류하지 않음
+ */
+function isListMethod(methodName: string, methodComment?: string): boolean {
+  // 주석에 '목록' 키워드가 있는지 확인 (우선순위 1순위)
+  // 예: '메뉴 목록', '배너 목록'
+  if (methodComment) {
+    const cleaned = methodComment.replace(/\/\*\*?|\*\//g, '').trim();
+    // '모듈명 목록' 또는 '목록' 패턴 확인
+    if (cleaned.includes('목록')) {
+      return true;
+    }
+  }
+  // '목록'으로 끝나는 경우 우선 (한국어 프로젝트 관례)
+  if (methodName.endsWith('목록')) {
+    return true;
+  }
+  // 'list' 또는 'List'를 포함하는 경우
+  if (methodName.includes('list') || methodName.includes('List')) {
+    return true;
+  }
+  // 그 외는 List 메서드로 분류하지 않음 (get으로 시작하는 것 제거)
+  return false;
+}
+
+/**
+ * Response 인터페이스에 페이징 정보가 있는지 확인
+ * 1. page: 필드 직접 확인
+ * 2. DataGridPageResponse 또는 ApiPageResponse 상속 확인
+ */
+function hasPageInResponse(content: string, responseType: string): boolean {
+  // Response 인터페이스 찾기 - 중괄호 균형 맞춤
+  const interfaceMatch = findInterface(content, responseType);
+
+  if (interfaceMatch) {
+    const body = interfaceMatch;
+
+    // 방법 1: page: 필드 직접 확인
+    if (/page:/.test(body)) {
+      return true;
+    }
+
+    // 방법 2: DataGridPageResponse 또는 ApiPageResponse 상속 확인
+    const extendsMatch = body.match(/extends\s+(DataGridPageResponse|ApiPageResponse)\b/);
+    if (extendsMatch) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Request 인터페이스에 pageNumber 또는 pageSize 필드가 있는지 확인
+ * listRequestValue 초기값 결정용
+ */
+export function hasPageInRequest(content: string, requestType: string): boolean {
+  // 모든 관련 인터페이스 내용 수집 (현재 + extends 체인)
+  let combinedBody = '';
+  const visited = new Set<string>();
+  let currentType = requestType;
+
+  while (currentType && !visited.has(currentType)) {
+    visited.add(currentType);
+
+    const searchStr = `export interface ${currentType}`;
+    const searchIdx = content.indexOf(searchStr);
+
+    if (searchIdx === -1) break;
+
+    const afterIdx = searchIdx + searchStr.length;
+    const remaining = content.slice(afterIdx);
+
+    const extendsMatch = remaining.match(/^\s*(?:extends\s+([\w<>]+)\s*)?\{/);
+    if (!extendsMatch) break;
+
+    const startIndex = afterIdx + extendsMatch[0].length;
+    let depth = 1;
+    let endIndex = startIndex;
+
+    for (let i = startIndex; i < content.length; i++) {
+      if (content[i] === '{') {
+        depth++;
+      } else if (content[i] === '}') {
+        depth--;
+        if (depth === 0) {
+          endIndex = i;
+          break;
+        }
+      }
+    }
+
+    const interfaceBody = content.slice(startIndex, endIndex);
+    combinedBody += interfaceBody + '\n';
+
+    if (extendsMatch[1]) {
+      currentType = extendsMatch[1];
+    } else {
+      break;
+    }
+  }
+
+  if (combinedBody) {
+    // pageNumber 또는 pageSize 필드 확인 (옵셔널 타입 `?:` 지원)
+    return /pageNumber\s*\?:|pageSize\s*\?:/.test(combinedBody);
+  }
+
+  return false;
+}
+
+/**
+ * Response 인터페이스에서 DTO 타입 추출
+ */
+function extractDtoType(content: string, responseType: string): string {
+  // Response 인터페이스 찾기 - 중괄호 균형 맞춤
+  const interfaceBody = findInterface(content, responseType);
+
+  if (interfaceBody) {
+    // ds: Type[] 형태 찾기 (단, 제너릭 타입 제외)
+    const dsMatch = interfaceBody.match(/ds:\s*(\w+)(\[|<)/);
+    if (dsMatch && dsMatch[2] === '[') {
+      const typeName = dsMatch[1];
+      // 제너릭 타입 키워드 제외
+      if (!['Record', 'Array', 'Map', 'Set', 'Promise', 'Partial', 'Required', 'Readonly'].includes(typeName)) {
+        return typeName;
+      }
+    }
+
+    // rs: Type 형태 찾기 (단, 제너릭 타입 제외)
+    const rsMatch = interfaceBody.match(/rs:\s*(\w+)(<|;|\n)/);
+    if (rsMatch && rsMatch[2] === '<') {
+      // 제너릭 타입이면 스킵
+      return '';
+    }
+    if (rsMatch) {
+      const typeName = rsMatch[1];
+      // 제너릭 타입 키워드 제외
+      if (!['Record', 'Array', 'Map', 'Set', 'Promise', 'Partial', 'Required', 'Readonly', 'undefined'].includes(typeName)) {
+        return typeName;
+      }
+    }
+  }
+
+  // 인터페이스에서 ds/rs를 찾지 못하면 unknown 반환
+  // (generate.ts에서 extractDtoFromResponse fallback 사용)
+  return 'unknown';
+}
+
+/**
+ * Response 인터페이스에서 응답 필드 구조 분석
+ * @returns { listField: string | null, detailField: string | null, isDirectObject: boolean }
+ */
+export function extractResponseFieldInfo(content: string, responseType: string): {
+  listField: string | null;
+  detailField: string | null;
+  isDirectObject: boolean;
+} {
+  const result = {
+    listField: null as string | null,
+    detailField: null as string | null,
+    isDirectObject: false,
+  };
+
+  const interfaceBody = findInterface(content, responseType);
+  if (!interfaceBody) {
+    console.error('[DEBUG] extractResponseFieldInfo - interface not found:', responseType);
+    return result;
+  }
+
+  console.error('[DEBUG] extractResponseFieldInfo - responseType:', responseType);
+  console.error('[DEBUG] extractResponseFieldInfo - interfaceBody:', interfaceBody.trim());
+
+  // 빈 인터페이스인 경우 (extends만 있고 본문이 없는 경우) -> 직접 객체
+  const trimmedBody = interfaceBody.trim();
+  if (trimmedBody === '') {
+    result.isDirectObject = true;
+    return result;
+  }
+
+  // 리스트 응답 필드 패턴 (우선순위 순)
+  const listPatterns = [
+    { regex: /ds:\s*(\w+)\[\]\s*;?/, field: 'ds' },
+    { regex: /list:\s*(\w+)\[\]\s*;?/, field: 'list' },
+    { regex: /items:\s*(\w+)\[\]\s*;?/, field: 'items' },
+    { regex: /data:\s*(\w+)\[\]\s*;?/, field: 'data' },
+  ];
+
+  for (const pattern of listPatterns) {
+    const match = interfaceBody.match(pattern.regex);
+    if (match) {
+      result.listField = pattern.field;
+      break;
+    }
+  }
+
+  // 상세 응답 필드 패턴 (우선순위 순)
+  const detailPatterns = [
+    { regex: /rs:\s*(\w+)(?![])\s*;?/, field: 'rs' },
+    { regex: /detail:\s*(\w+)(?![])\s*;?/, field: 'detail' },
+    { regex: /data:\s*(\w+)(?![])\s*;?/, field: 'data' },
+  ];
+
+  for (const pattern of detailPatterns) {
+    const match = interfaceBody.match(pattern.regex);
+    if (match) {
+      const typeName = match[1];
+      // 제너릭 타입 키워드 제외
+      if (!['Record', 'Array', 'Map', 'Set', 'Promise', 'Partial', 'Required', 'Readonly', 'undefined'].includes(typeName)) {
+        result.detailField = pattern.field;
+        break;
+      }
+    }
+  }
+
+  // 필드가 하나도 없고, 인터페이스에 필드가 하나만 있는 경우 직접 객체일 수 있음
+  const lines = interfaceBody.split('\n').filter(line => line.trim() && !line.trim().startsWith('//'));
+  if (lines.length === 0 && !result.listField && !result.detailField) {
+    // 빈 인터페이스 (extends만 있음) -> 직접 객체
+    result.isDirectObject = true;
+  } else if (lines.length === 1 && !result.listField && !result.detailField) {
+    const fieldMatch = lines[0].match(/^\s*(\w+)\s*:\s*(\w+);/);
+    if (fieldMatch) {
+      result.isDirectObject = true;
+      result.detailField = fieldMatch[1]; // 필드명 자체를 반환
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Request 인터페이스에서 첫 번째 필드 이름 추출
+ * __status__ 패턴용 ID 필드 추출에 사용
+ * 우선순위: No/Number/Id/ID로 끝나는 필드 -> 첫 번째 필드
+ * extends 체인을 따라감
+ */
+export function extractIdFieldFromRequest(content: string, requestType: string): { fieldName: string; fieldType: string; isOptional: boolean } {
+  // 모든 관련 인터페이스 내용 수집 (현재 + extends 체인)
+  let combinedBody = '';
+
+  // extends 체인 추적
+  const visited = new Set<string>();
+  let currentType = requestType;
+
+  while (currentType && !visited.has(currentType)) {
+    visited.add(currentType);
+
+    // 인터페이스 선언 찾기 (본문 포함)
+    const searchStr = `export interface ${currentType}`;
+    const searchIdx = content.indexOf(searchStr);
+
+    if (searchIdx === -1) break;
+
+    const afterIdx = searchIdx + searchStr.length;
+    const remaining = content.slice(afterIdx);
+
+    // extends 추출 및 본문 찾기
+    const extendsMatch = remaining.match(/^\s*(?:extends\s+(\w+)\s*)?\{/);
+    if (!extendsMatch) break;
+
+    const startIndex = afterIdx + extendsMatch[0].length;
+    let depth = 1;
+    let endIndex = startIndex;
+
+    for (let i = startIndex; i < content.length; i++) {
+      if (content[i] === '{') {
+        depth++;
+      } else if (content[i] === '}') {
+        depth--;
+        if (depth === 0) {
+          endIndex = i;
+          break;
+        }
+      }
+    }
+
+    const interfaceBody = content.slice(startIndex, endIndex);
+    combinedBody += interfaceBody + '\n';
+
+    // extends 타입 추출
+    if (extendsMatch[1]) {
+      currentType = extendsMatch[1];
+    } else {
+      break;
+    }
+  }
+
+  if (combinedBody) {
+    const lines = combinedBody.split('\n').filter(line => line.trim() && !line.trim().startsWith('//'));
+
+    // DEBUG: ID 필드 추출 로깅
+    console.error('[DEBUG] extractIdFieldFromRequest - requestType:', requestType);
+    console.error('[DEBUG] combinedBody lines (first 10):', lines.slice(0, 10).map(l => l.trim()));
+
+    // 우선순위 1: No 또는 Number로 끝나는 필드 찾기 (게시판번호, 회원번호 등)
+    for (const line of lines) {
+      const fieldMatch = line.match(/^\s*(\w+)\s*(\?)?:\s*(.+?);?$/);
+      if (fieldMatch) {
+        const fieldName = fieldMatch[1];
+        const isOptional = fieldMatch[2] !== undefined; // ?가 있으면 optional
+        const fieldType = fieldMatch[3].trim();
+        // __status__, 페이징 필드는 제외
+        if (fieldName !== '__status__' && !/(pageNumber|pageSize|page|limit|offset)$/.test(fieldName) && /(No|Number)$/.test(fieldName)) {
+          return { fieldName, fieldType: normalizeFieldType(fieldType, isOptional), isOptional };
+        }
+      }
+    }
+
+    // 우선순위 2: Id 또는 ID로 끝나는 필드 찾기 (단, uploadId, fileId 등은 제외)
+    for (const line of lines) {
+      const fieldMatch = line.match(/^\s*(\w+)\s*(\?)?:\s*(.+?);?$/);
+      if (fieldMatch) {
+        const fieldName = fieldMatch[1];
+        const isOptional = fieldMatch[2] !== undefined;
+        const fieldType = fieldMatch[3].trim();
+        // __status__, 페이징 필드는 제외
+        if (fieldName !== '__status__' && !/(pageNumber|pageSize|page|limit|offset)$/.test(fieldName) && /(Id|ID)$/.test(fieldName) && !/(Upload|File|Image|Thumb)/i.test(fieldName)) {
+          return { fieldName, fieldType: normalizeFieldType(fieldType, isOptional), isOptional };
+        }
+      }
+    }
+
+    // 우선순위 3: 첫 번째 필드 반환 (단, __status__, 페이징 필드 제외)
+    for (const line of lines) {
+      const fieldMatch = line.match(/^\s*(\w+)\s*(\??):\s*(.+?);?$/);
+      if (fieldMatch) {
+        const fieldName = fieldMatch[1];
+        const isOptional = fieldMatch[2] !== undefined;
+        const fieldType = fieldMatch[3].trim();
+        // __status__, rowId, crtrId, crtrNm, creatDtm, upusrId, upusrNm, upddeDtm, 페이징 필드는 ID로 사용하지 않음
+        if (!/^(__status__|rowId|crtrId|crtrNm|creatDtm|upusrId|upusrNm|upddeDtm|pageNumber|pageSize|page|limit|offset)$/.test(fieldName)) {
+          return { fieldName, fieldType: normalizeFieldType(fieldType, isOptional), isOptional };
+        }
+      }
+    }
+
+    // 우선순위 4: Request 타입이 *Req로 끝나면 그 첫 번째 필드 사용 (DefaultDto 제외)
+    // combinedBody는 extends 체인의 모든 필드를 포함하므로, 방문 순서대로 첫 번째 *Req 인터페이스의 필드만 사용
+    if (requestType.endsWith('Req')) {
+      // 원본 content에서 *Req 인터페이스 개별 추출
+      const reqInterfaceRegex = new RegExp(`export interface (\\w+Req) \\{([\\s\\S]*?)\\n\\}`, 'g');
+      let reqMatch;
+      const firstReqFields: string[] = [];
+
+      // 첫 번째 *Req 인터페이스 찾기
+      while ((reqMatch = reqInterfaceRegex.exec(content)) !== null) {
+        const reqName = reqMatch[1];
+        const reqBody = reqMatch[2];
+        const reqLines = reqBody.split('\n').filter(line => line.trim() && !line.trim().startsWith('//'));
+
+        for (const line of reqLines) {
+          const fieldMatch = line.match(/^\s*(\w+)\s*(\??):\s*(.+?);?$/);
+          if (fieldMatch) {
+            const fieldName = fieldMatch[1];
+            // 페이징 필드와 메타데이터 필드 제외
+            if (!/^(__status__|rowId|crtrId|crtrNm|creatDtm|upusrId|upusrNm|upddeDtm|pageNumber|pageSize|page|limit|offset)$/.test(fieldName)) {
+              return {
+                fieldName,
+                fieldType: normalizeFieldType(fieldMatch[3].trim(), fieldMatch[2] !== undefined),
+                isOptional: fieldMatch[2] !== undefined
+              };
+            }
+          }
+        }
+        break; // 첫 번째 *Req 인터페이스만 처리
+      }
+    }
+  }
+
+  return { fieldName: 'id', fieldType: 'string | number', isOptional: false }; // 기본값
+}
+
+/**
+ * 필드 타입을 정규화하여 'string' | 'number' | 'string | number' | 'string | undefined' 등으로 반환
+ */
+function normalizeFieldType(fieldType: string, isOptional: boolean): string {
+  const type = fieldType.replace(/\|/g, ' | ').toLowerCase().trim();
+  let baseType = '';
+
+  // string | number 또는 number | string
+  if ((type.includes('string') && type.includes('number')) || (type.includes('number') && type.includes('string'))) {
+    baseType = 'string | number';
+  }
+  // string
+  else if (type.includes('string') && !type.includes('number')) {
+    baseType = 'string';
+  }
+  // number
+  else if (type.includes('number') && !type.includes('string')) {
+    baseType = 'number';
+  }
+  else {
+    baseType = 'string | number'; // 기본값
+  }
+
+  // optional이면 undefined 추가
+  return isOptional ? `${baseType} | undefined` : baseType;
+}
+
+/**
+ * 중괄호 균형을 맞춰 인터페이스 내용 추출
+ */
+function findInterface(content: string, interfaceName: string): string | undefined {
+  // 인터페이스 시작 위치 찾기
+  // 단순 문자열 검색 후 정규식으로 정확성 확인
+  const searchStr = `export interface ${interfaceName}`;
+  const searchIdx = content.indexOf(searchStr);
+
+  if (searchIdx === -1) {
+    return undefined;
+  }
+
+  // 검색된 위치 뒤에 extends나 {가 오는지 확인
+  const afterIdx = searchIdx + searchStr.length;
+  const remaining = content.slice(afterIdx);
+  // extends SomeType { 또는 바로 { 둘 다 허용
+  // 제네릭 타입도 처리하기 위해 <> 허용
+  const match = remaining.match(/^\s*(?:extends\s+[\w<>]+\s*)?\{/);
+
+  if (!match) {
+    return undefined;
+  }
+
+  const startIndex = afterIdx + match[0].length;
+  let depth = 1;
+  let endIndex = startIndex;
+
+  // 중괄호 균형 맞추기
+  for (let i = startIndex; i < content.length; i++) {
+    if (content[i] === '{') {
+      depth++;
+    } else if (content[i] === '}') {
+      depth--;
+      if (depth === 0) {
+        endIndex = i;
+        break;
+      }
+    }
+  }
+
+  if (depth !== 0) {
+    return undefined;
+  }
+
+  return content.slice(startIndex, endIndex);
+}
+
+/**
+ * 메서드 주석 추출
+ * @param content Repository 파일 전체 내용
+ * @param methodName 메서드 이름
+ * @param methodIndex 메서드 시작 위치
+ * @returns 주석 문자열 또는 undefined
+ */
+function extractMethodComment(content: string, methodName: string, methodIndex: number): string | undefined {
+  // 정확한 메서드 이름 매칭을 위한 regex (특수문자 이스케이프)
+  const escapedMethodName = methodName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const methodRegex = new RegExp(`async\\s+(${escapedMethodName})\\s*\\(`);
+  const match = content.match(methodRegex);
+
+  if (!match) return undefined;
+
+  const exactMethodIndex = match.index;
+
+  // 메서드 바로 앞의 내용 추출
+  const contentBeforeMethod = content.substring(0, exactMethodIndex).trim();
+
+  // 마지막 주석 찾기
+  const lastCommentStart = contentBeforeMethod.lastIndexOf('/*');
+  if (lastCommentStart === -1) return undefined;
+
+  const lastCommentEnd = contentBeforeMethod.indexOf('*/', lastCommentStart);
+  if (lastCommentEnd === -1) return undefined;
+
+  const commentCandidate = contentBeforeMethod.substring(lastCommentStart, lastCommentEnd + 2).trim();
+
+  // 주석과 메서드 사이의 내용 확인 (공백/줄바꿈만 허용)
+  const betweenCommentAndMethod = contentBeforeMethod.substring(lastCommentEnd + 2).trim();
+
+  // 주석과 메서드 사이에 다른 async 키워드가 있으면 안 됨
+  const nextAsyncIndex = betweenCommentAndMethod.lastIndexOf('async ');
+  if (nextAsyncIndex !== -1) return undefined;
+
+  return commentCandidate;
+}
+
+/**
+ * Request 인터페이스에서 dateRange/dayjs 패턴 감지
+ * bgnDtm/endDtm 또는 startDateTime/endDateTime 쌍을 찾음
+ * Dt/Dtm으로 끝나는 필드가 1개 이상 있으면 dayjs import 필요
+ * extends로 확장된 타입도 체크
+ */
+function detectDateRangePattern(content: string, requestType: string): DateRangeField | undefined {
+  // Request 인터페이스의 전체 선언을 찾기 (extends 정보 포함)
+  const searchStr = `export interface ${requestType}`;
+  const searchIdx = content.indexOf(searchStr);
+
+  if (searchIdx === -1) {
+    return undefined;
+  }
+
+  // interface 선언 시작부터 중괄호 끝까지 전체 추출
+  const afterIdx = searchIdx + searchStr.length;
+  // extends SomeType { 또는 바로 { 둘 다 허용
+  // 제네릭 타입도 처리하기 위해 <> 허용
+  // 타입 이름도 캡처 (재귀 호출용)
+  const match = content.slice(afterIdx).match(/^\s*(?:extends\s+([\w<>]+)\s*)?\{/);
+
+  if (!match) {
+    return undefined;
+  }
+
+  const startIndex = afterIdx + match[0].length;
+  let depth = 1;
+  let endIndex = startIndex;
+
+  for (let i = startIndex; i < content.length; i++) {
+    if (content[i] === '{') {
+      depth++;
+    } else if (content[i] === '}') {
+      depth--;
+      if (depth === 0) {
+        endIndex = i;
+        break;
+      }
+    }
+  }
+
+  if (depth !== 0) {
+    return undefined;
+  }
+
+  // interface 본문
+  const interfaceBody = content.slice(startIndex, endIndex);
+
+  // Dt/Dtm으로 끝나는 필드 개수 카운트 (dayjs import 필요 여부 판단)
+  const dtFieldsMatch = interfaceBody.matchAll(/(\w+(?:Dt|Dtm))\s*\??:\s*string/g);
+  const dtFields = Array.from(dtFieldsMatch).map(m => m[1]);
+  const hasDtField = dtFields.length > 0;
+
+  // 패턴 1: bgnDtm/endDtm (한국어 프로젝트 관례)
+  const hasBgnDtm = /bgnDtm\s*\??:\s*string/.test(interfaceBody);
+  const hasEndDtm = /endDtm\s*\??:\s*string/.test(interfaceBody);
+
+  if (hasBgnDtm && hasEndDtm) {
+    return {
+      startField: 'bgnDtm',
+      endField: 'endDtm',
+      searchType: 'bgnDtm',
+      hasDayJs: hasDtField,
+    };
+  }
+
+  // 패턴 2: startDateTime/endDateTime (영어 관례)
+  const hasStartDateTime = /startDateTime\s*\??:\s*string/.test(interfaceBody);
+  const hasEndDateTime = /endDateTime\s*\??:\s*string/.test(interfaceBody);
+
+  if (hasStartDateTime && hasEndDateTime) {
+    return {
+      startField: 'startDateTime',
+      endField: 'endDateTime',
+      searchType: 'startDateTime',
+      hasDayJs: hasDtField,
+    };
+  }
+
+  // Dt/Dtm 필드가 1개 이상 있는 경우 (쌍은 아니지만 dayjs는 필요)
+  if (hasDtField) {
+    return {
+      startField: '',
+      endField: '',
+      searchType: 'unknown',
+      hasDayJs: true,
+    };
+  }
+
+  // extends로 확장된 타입 체크 (match[1]은 extends 뒤의 타입 이름)
+  if (match[1]) {
+    const baseType = match[1];
+    // 기본 타입도 재귀적으로 체크
+    return detectDateRangePattern(content, baseType);
+  }
+
+  return undefined;
+}
+
+/**
+ * Request 인터페이스에서 필수 필드 추출
+ * 옵셔널(?)이 아닌 필드들 중에서 pageNumber, pageSize는 제외
+ */
+export function extractRequiredFieldsFromRequest(content: string, requestType: string): string[] {
+  const requiredFields: string[] = [];
+  const excludedFields = new Set(['pageNumber', 'pageSize', 'dateRange']);
+
+  // 모든 관련 인터페이스 내용 수집 (현재 + extends 체인)
+  let combinedBody = '';
+  const visited = new Set<string>();
+  let currentType = requestType;
+
+  while (currentType && !visited.has(currentType)) {
+    visited.add(currentType);
+
+    const searchStr = `export interface ${currentType}`;
+    const searchIdx = content.indexOf(searchStr);
+
+    if (searchIdx === -1) break;
+
+    const afterIdx = searchIdx + searchStr.length;
+    const remaining = content.slice(afterIdx);
+
+    const extendsMatch = remaining.match(/^\s*(?:extends\s+([\w<>]+)\s*)?\{/);
+    if (!extendsMatch) break;
+
+    const startIndex = afterIdx + extendsMatch[0].length;
+    let depth = 1;
+    let endIndex = startIndex;
+
+    for (let i = startIndex; i < content.length; i++) {
+      if (content[i] === '{') {
+        depth++;
+      } else if (content[i] === '}') {
+        depth--;
+        if (depth === 0) {
+          endIndex = i;
+          break;
+        }
+      }
+    }
+
+    const interfaceBody = content.slice(startIndex, endIndex);
+    combinedBody += interfaceBody + '\n';
+
+    if (extendsMatch[1]) {
+      currentType = extendsMatch[1];
+    } else {
+      break;
+    }
+  }
+
+  if (combinedBody) {
+    const lines = combinedBody.split('\n').filter(line => line.trim() && !line.trim().startsWith('//'));
+
+    for (const line of lines) {
+      // 필수 필드 (옵셔널 ?이 없는 필드)
+      const requiredMatch = line.match(/^\s*(\w+)\s*:/);
+      if (requiredMatch && !excludedFields.has(requiredMatch[1])) {
+        requiredFields.push(requiredMatch[1]);
+      }
+    }
+  }
+
+  return requiredFields;
+}
+
+/**
+ * 메서드 정보 추출 헬퍼 함수
+ */
+function extractMethodInfo(
+  methodName: string,
+  params: string,
+  explicitReturnType: string | undefined,
+  methodComment: string | undefined,
+  repoContent: string,
+  combinedContent: string,
+  analysis: InterfaceAnalysis
+): MethodInfo {
+  const methodInfo: MethodInfo = {
+    name: methodName,
+    isListMethod: isListMethod(methodName, methodComment),
+    comment: methodComment,
+  };
+
+  // 첫 번째 파라미터 이름 추출 (예: id, bbscttNo)
+  if (params.trim()) {
+    const firstParam = params.split(',').map(p => p.trim()).filter(p => p)[0];
+    if (firstParam) {
+      const paramNameMatch = firstParam.match(/^(\w+)/);
+      if (paramNameMatch) {
+        methodInfo.firstParamName = paramNameMatch[1];
+      }
+    }
+  }
+
+  // Request 타입 추출 (params: Type 또는 params: Type[])
+  // 복잡한 타입 이름도 추출 가능하도록 개선 (예: PostAppBannerMgmtDeleteRequest)
+  // 첫 번째 파라미터만 추출 (쉼표나 닫는 괄호까지)
+  const firstParamOnly = params.split(',')[0].trim();
+  const paramMatch = firstParamOnly.match(/params:\s*([\w]+(?:\[\])?)/);
+  if (paramMatch) {
+    methodInfo.requestType = paramMatch[1];
+    // 배열 타입인지 확인
+    methodInfo.isRequestArray = paramMatch[1].endsWith('[]');
+    if (methodInfo.isRequestArray) {
+      methodInfo.requestType = paramMatch[1].slice(0, -2); // [] 제거
+    }
+  }
+
+  // Response 타입 추출
+  let responseType = explicitReturnType;
+
+  // 명시적 반환 타입이 없으면 메서드 본문에서 apiWrapper 타입 추출 (Repository인 경우)
+  if (!responseType) {
+    const methodIndex = repoContent.indexOf(`async ${methodName}(`);
+    if (methodIndex !== -1) {
+      const nextMethodIdx = repoContent.indexOf('\n  async', methodIndex + 1);
+      const classEndIdx = repoContent.indexOf('\n}\n', methodIndex);
+      const methodEnd = nextMethodIdx > 0 ? nextMethodIdx : (classEndIdx > 0 ? classEndIdx : repoContent.length);
+      const methodBody = repoContent.slice(methodIndex, methodEnd);
+
+      const wrapperMatch = methodBody.match(/(?:this\.)?_?apiWrapper<([^>]+)>/);
+      if (wrapperMatch) {
+        responseType = wrapperMatch[1];
+      }
+    }
+  }
+
+  if (responseType && responseType !== 'void') {
+    const responseMatch = responseType.match(/Post(\w+Response)|Get(\w+Response)/);
+    if (responseMatch) {
+      methodInfo.responseType = responseMatch[0] || responseType;
+    } else {
+      methodInfo.responseType = responseType;
+    }
+
+    // 페이징 여부 확인
+    methodInfo.hasPage = hasPageInResponse(combinedContent, methodInfo.responseType);
+    if (methodInfo.hasPage) {
+      analysis.hasPage = true;
+    }
+
+    // 응답 필드 구조 분석
+    const responseFieldInfo = extractResponseFieldInfo(combinedContent, methodInfo.responseType);
+    methodInfo.responseListField = responseFieldInfo.listField;
+    methodInfo.responseDetailField = responseFieldInfo.detailField;
+
+    // 응답 타입 기반 isListMethod 재설정 (주석보다 응답 구조 우선)
+    // 응답에 배열 필드(ds[], list[], items[] 등)가 있으면 리스트 메서드
+    if (responseFieldInfo.listField) {
+      methodInfo.isListMethod = true;
+    } else if (responseFieldInfo.detailField || responseFieldInfo.isDirectObject) {
+      // 응답이 단일 객체(detail, rs 등)이면 리스트 메서드가 아님
+      methodInfo.isListMethod = false;
+    }
+    // 응답 구조를 확인할 수 없으면 주석 기반 판단 유지
+  }
+
+  return methodInfo;
+}
+
+/**
+ * camelCase 변환
+ */
+function toCamelCase(str: string): string {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
+/**
+ * Request 인터페이스에서 필드 정보 추출
+ * SearchParams 생성 등에 활용
+ */
+export function extractRequestFields(content: string, requestType: string): RequestFieldInfo[] {
+  const fields: RequestFieldInfo[] = [];
+
+  // 빈 인터페이스이거나 void인 경우
+  if (!requestType || requestType === 'void' || requestType === 'any') {
+    return fields;
+  }
+
+  // 인터페이스 본문 추출 (extends 체인 포함)
+  let interfaceBody = '';
+  const visited = new Set<string>();
+  let currentType = requestType;
+
+  while (currentType && !visited.has(currentType)) {
+    visited.add(currentType);
+
+    const body = findInterface(content, currentType);
+    if (body) {
+      interfaceBody += body + '\n';
+
+      // extends 추출
+      const extendsMatch = body.match(/extends\s+([\w\d]+)/);
+      if (extendsMatch) {
+        currentType = extendsMatch[1];
+      } else {
+        break;
+      }
+    } else {
+      break;
+    }
+  }
+
+  if (!interfaceBody.trim()) {
+    return fields;
+  }
+
+  // 필드 파싱 (주석 포함)
+  const fieldRegex = /(?:\/\/\s*(.+?)\s*\n)?\s*(\w+)\??\s*:\s*(.+?);/g;
+  let match;
+
+  while ((match = fieldRegex.exec(interfaceBody)) !== null) {
+    const [, comment, name, type] = match;
+    const isOptional = match[0].includes('?');
+
+    // 필드 타입 분류
+    const fieldType = classifyFieldType(name, type);
+
+    fields.push({
+      name,
+      type: type.trim(),
+      fieldType,
+      isOptional,
+      comment: comment?.trim(),
+    });
+  }
+
+  return fields;
+}
+
+/**
+ * 필드 타입 분류
+ */
+function classifyFieldType(name: string, type: string): RequestFieldType {
+  const lowerName = name.toLowerCase();
+
+  // 페이지네이션
+  if (lowerName === 'pageNumber' || lowerName === 'pageSize' || lowerName === 'page' || lowerName === 'limit') {
+    return 'page';
+  }
+
+  // 날짜 범위 (bgnDtm, endDtm, startDateTime, endDateTime, bgnDt, endDt)
+  if (lowerName.includes('bgn') || lowerName.includes('start') || lowerName.includes('end')) {
+    return 'dateRange';
+  }
+
+  // 검색어
+  if (lowerName.includes('search') && (lowerName.includes('text') || lowerName.includes('keyword') || lowerName === 'searchtext' || lowerName === 'search')) {
+    return 'search';
+  }
+
+  // 검색 구분
+  if (lowerName.includes('search') && (lowerName.includes('type') || lowerName.includes('div') || lowerName.includes('kind'))) {
+    return 'searchType';
+  }
+
+  // Y/N 필드
+  if (lowerName.endsWith('yn') || lowerName.endsWith('Yn')) {
+    return 'yn';
+  }
+
+  // 코드 필드 (Cd로 끝남)
+  if (lowerName.endsWith('cd') || lowerName.endsWith('Cd')) {
+    return 'code';
+  }
+
+  // 숫자 필드
+  if (type === 'number' || type === 'bigint') {
+    return 'number';
+  }
+
+  // 문자열 필드
+  if (type === 'string') {
+    return 'string';
+  }
+
+  return 'unknown';
+}
+
+/**
+ * 필드 정보에서 특정 타입의 필드만 추출
+ */
+export function filterFieldsByType(fields: RequestFieldInfo[], fieldType: RequestFieldType): RequestFieldInfo[] {
+  return fields.filter(f => f.fieldType === fieldType);
+}