@axboot-mcp/mcp-server 1.0.0

package/src/handlers/generate-hook.ts

@@ -0,0 +1,950 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { analyzeInterface, InterfaceAnalysis, MethodInfo } from './analyze.js';
+
+/**
+ * 프로젝트 루트 찾기 (tsconfig.json이 있는 위치)
+ */
+async function findProjectRoot(startPath: string): Promise<string> {
+  let currentDir = path.dirname(startPath);
+
+  for (let i = 0; i < 10; i++) {
+    const tsconfigPath = path.join(currentDir, 'tsconfig.json');
+
+    try {
+      await fs.access(tsconfigPath);
+      return currentDir;
+    } catch {
+      const parentDir = path.dirname(currentDir);
+      if (parentDir === currentDir) {
+        break;
+      }
+      currentDir = parentDir;
+    }
+  }
+
+  return process.cwd();
+}
+
+/**
+ * package.json 확인하여 type-check 스크립트 확인
+ */
+async function hasTypeCheckScript(projectRoot: string): Promise<boolean> {
+  try {
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    const content = await fs.readFile(packageJsonPath, 'utf-8');
+    const packageJson = JSON.parse(content);
+
+    return !!(packageJson.scripts && packageJson.scripts['type-check']);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 타입 체크 실행 (프로젝트 구조 자동 분석)
+ */
+async function typeCheck(filePath: string): Promise<{ success: boolean; errors?: string[] }> {
+  try {
+    const projectRoot = await findProjectRoot(filePath);
+    const hasTypeCheck = await hasTypeCheckScript(projectRoot);
+
+    let command: string;
+    let args: string[];
+
+    if (hasTypeCheck) {
+      command = 'npm';
+      args = ['run', 'type-check'];
+    } else {
+      command = 'npx';
+      args = ['tsc', '--noEmit', filePath];
+    }
+
+    execSync(
+      `${command} ${args.join(' ')}`,
+      {
+        encoding: 'utf-8',
+        cwd: projectRoot,
+        stdio: ['ignore', 'ignore', 'pipe'],
+        timeout: 30000
+      }
+    );
+
+    return { success: true };
+  } catch (error: any) {
+    const stderr = error.stderr || error.stdout || '';
+    const errors = stderr
+      .split('\n')
+      .filter((line: string) => line.includes('error TS'))
+      .map((line: string) => line.trim())
+      .filter((line: string) => line.length > 0);
+    return { success: false, errors };
+  }
+}
+
+/**
+ * Lint 및 Prettier 실행 (프로젝트 루트 기준)
+ */
+async function runLintAndPrettier(filePath: string): Promise<void> {
+  // 프로젝트 루트 찾기
+  const projectRoot = await findProjectRoot(filePath);
+  const relativePath = path.relative(projectRoot, filePath);
+
+  try {
+    execSync(`npx prettier --write "${relativePath}"`, { cwd: projectRoot, stdio: 'ignore' });
+  } catch {
+    // Prettier 실패는 무시
+  }
+
+  try {
+    execSync(`npx eslint --fix "${relativePath}"`, { cwd: projectRoot, stdio: 'ignore' });
+  } catch {
+    // ESLint 실패는 무시
+  }
+}
+
+// ===== 포함/제외 키워드 =====
+
+const INCLUDE_KEYWORDS = ['조회', '목록'];
+const EXCLUDE_KEYWORDS = ['저장', '삭제', '수정', '엑셀', '업로드', '다운로드', 'excel', 'upload', 'download'];
+
+/**
+ * 메서드가 훅 생성에 포함될지 확인
+ */
+function shouldIncludeMethod(method: MethodInfo): boolean {
+  if (!method.comment) {
+    return false;
+  }
+
+  const commentLower = method.comment.toLowerCase();
+
+  // 제외 키워드 확인
+  for (const exclude of EXCLUDE_KEYWORDS) {
+    if (commentLower.includes(exclude)) {
+      return false;
+    }
+  }
+
+  // 포함 키워드 확인
+  for (const include of INCLUDE_KEYWORDS) {
+    if (commentLower.includes(include)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// ===== 네이밍 추출 =====
+
+/**
+ * 리스트 변수명 추출 (옵션 1: 메서드명 기반 자동 네이밍)
+ * postMemberListMember → list (접미사가 Entity면 기본값)
+ * postMemberListAdmin → adminList
+ * postMemberList → list (접미사 없으면 기본값)
+ */
+function extractListName(methodName: string, entityName: string): string {
+  const pattern = new RegExp(`post${entityName}List(.*)`);
+  const match = methodName.match(pattern);
+
+  if (match) {
+    const suffix = match[1];
+    if (!suffix) return 'list'; // 접미사 없으면 기본값
+
+    // 접미사가 Entity명과 같으면 기본값 (postMemberListMember → list)
+    if (suffix.toLowerCase() === entityName.toLowerCase()) {
+      return 'list';
+    }
+
+    // 첫 글자 소문자로 변환 (camelCase)
+    return suffix.charAt(0).toLowerCase() + suffix.slice(1) + 'List';
+  }
+
+  return 'list';
+}
+
+/**
+ * 리스트 함수명 추출
+ * postMemberListMember → getList (접미사가 Entity면 getList)
+ * postMemberListAdmin → getAdminList
+ * postMemberList → getList
+ */
+function extractListFunctionName(methodName: string, entityName: string): string {
+  const listName = extractListName(methodName, entityName);
+
+  // list → getList, adminList → getAdminList
+  return 'get' + listName.charAt(0).toUpperCase() + listName.slice(1);
+}
+
+/**
+ * 단건 변수명 추출
+ * postMemberDetail → detail
+ * postMemberInfo → info
+ * postMemberProfile → profile
+ * postMember → member
+ * getMemberDetail → detail
+ * getMember → member
+ */
+function extractDetailName(methodName: string, entityName: string): string {
+  // post{Entity}{Suffix} 패턴
+  const postPattern = new RegExp(`post${entityName}(.*)`);
+  const postMatch = methodName.match(postPattern);
+
+  if (postMatch) {
+    const suffix = postMatch[1];
+    if (!suffix) return entityName.toLowerCase(); // postMember → member
+
+    // 첫 글자 소문자로 변환 (camelCase)
+    return suffix.charAt(0).toLowerCase() + suffix.slice(1);
+  }
+
+  // get{Entity}{Suffix} 패턴
+  const getPattern = new RegExp(`get${entityName}(.*)`);
+  const getMatch = methodName.match(getPattern);
+
+  if (getMatch) {
+    const suffix = getMatch[1];
+    if (!suffix) return entityName.toLowerCase(); // getMember → member
+
+    return suffix.charAt(0).toLowerCase() + suffix.slice(1);
+  }
+
+  return 'detail'; // 기본값
+}
+
+/**
+ * 단건 함수명 추출
+ * postMemberDetail → getDetail
+ * postMemberInfo → getInfo
+ * postMember → getMember
+ * getMemberDetail → getDetail
+ */
+function extractDetailFunctionName(methodName: string, entityName: string): string {
+  const detailName = extractDetailName(methodName, entityName);
+
+  // detail → getDetail, info → getInfo, member → getMember
+  return 'get' + detailName.charAt(0).toUpperCase() + detailName.slice(1);
+}
+
+// ===== 중복 처리 (옵션 C: 중복 시만 구분) =====
+
+interface ProcessedMethod {
+  method: MethodInfo;
+  listName?: string;
+  functionName: string;
+  detailName?: string;
+}
+
+/**
+ * 중복 확인 후 접두사 추가
+ * 1. 기본 네이밍으로 모든 메서드의 이름을 생성
+ * 2. 중복이 있는 메서드에만 접두사 추가
+ */
+function resolveDuplicateNames(processedMethods: ProcessedMethod[], entityName: string): ProcessedMethod[] {
+  // 이름별로 그룹화
+  const nameMap = new Map<string, ProcessedMethod[]>();
+
+  processedMethods.forEach(pm => {
+    const baseName = pm.listName || pm.detailName || '';
+    if (!nameMap.has(baseName)) {
+      nameMap.set(baseName, []);
+    }
+    nameMap.get(baseName)!.push(pm);
+  });
+
+  // 중복이 있는 경우 접두사 추가
+  nameMap.forEach((duplicates, baseName) => {
+    if (duplicates.length > 1) {
+      // 중복이 있으면 접두사 추가 (post/get 또는 List/Detail 구분)
+      duplicates.forEach((pm) => {
+        const isPost = pm.method.name.startsWith('post');
+        const prefix = isPost ? 'post' : 'get';
+        const capitalized = prefix.charAt(0).toUpperCase() + prefix.slice(1);
+
+        if (pm.listName) {
+          // 목록은 숫자로 구분
+          const idx = duplicates.indexOf(pm);
+          pm.listName = baseName + (idx + 1);
+          pm.functionName = 'get' + baseName.charAt(0).toUpperCase() + baseName.slice(1) + (idx + 1);
+        } else {
+          // 단건은 post/get 접두사로 구분
+          pm.detailName = capitalized + baseName.charAt(0).toUpperCase() + baseName.slice(1);
+          pm.functionName = 'get' + pm.detailName.charAt(0).toUpperCase() + pm.detailName.slice(1);
+        }
+      });
+    }
+  });
+
+  return processedMethods;
+}
+
+// ===== DTO 타입 추출 =====
+
+/**
+ * Response 타입에서 DTO 타입 추출
+ * PostMemberListMemberResponse → MemberRes
+ * PostPbReprtListPbReprtResponse → PbReprtRes
+ */
+function extractDtoType(responseType: string): string {
+  if (!responseType) return 'unknown';
+
+  // Post{Entity}List{Response} → {Entity}Res
+  // Post{Entity}List{Suffix}Response → {Suffix}Res
+  // 정규식: Post로 시작하고 List가 있고 Response로 끝나는 패턴
+  const listMatch = responseType.match(/Post(\w+)List(\w+)Response/);
+  if (listMatch) {
+    const entityPart = listMatch[1]; // PbReprt, Member
+    const suffixPart = listMatch[2]; // PbReprt, Member, Admin
+
+    // PostPbReprtListPbReprtResponse → PbReprtRes
+    // PostMemberListMemberResponse → MemberRes
+    if (suffixPart.toLowerCase() === entityPart.toLowerCase()) {
+      return entityPart + 'Res';
+    }
+
+    // PostMemberListAdminResponse → AdminRes
+    return suffixPart + 'Res';
+  }
+
+  // Post{Entity}{Suffix}Response → {Suffix}Res (단건 조회)
+  const detailMatch = responseType.match(/Post(\w+)(\w+)Response/);
+  if (detailMatch) {
+    const entityPart = detailMatch[1];
+    const suffixPart = detailMatch[2];
+    return suffixPart + 'Res';
+  }
+
+  // Get{Entity}{Detail}Response → {Entity}DetailRes
+  const getMatch = responseType.match(/Get(\w+)(\w+)Response/);
+  if (getMatch) {
+    return getMatch[1] + getMatch[2] + 'Res';
+  }
+
+  return 'unknown';
+}
+
+// ===== Request Interface에서 dateRange 패턴 추출 =====
+
+interface DateRangePattern {
+  hasDateRange: boolean;
+  startField?: string;
+  endField?: string;
+}
+
+/**
+ * Request 타입에서 dateRange 패턴 추출
+ */
+function extractDateRangeFromRequest(requestType: string, combinedContent: string): DateRangePattern {
+  if (!requestType || requestType === 'void' || requestType === 'any') {
+    return { hasDateRange: false };
+  }
+
+  // Request 인터페이스 찾기
+  const searchStr = `export interface ${requestType}`;
+  const searchIdx = combinedContent.indexOf(searchStr);
+
+  if (searchIdx === -1) {
+    return { hasDateRange: false };
+  }
+
+  const afterIdx = searchIdx + searchStr.length;
+  const remaining = combinedContent.slice(afterIdx);
+
+  const match = remaining.match(/^\s*(?:extends\s+[\w<>]+\s*)?\{/);
+  if (!match) {
+    return { hasDateRange: false };
+  }
+
+  const startIndex = afterIdx + match[0].length;
+  let depth = 1;
+  let endIndex = startIndex;
+
+  for (let i = startIndex; i < combinedContent.length; i++) {
+    if (combinedContent[i] === '{') {
+      depth++;
+    } else if (combinedContent[i] === '}') {
+      depth--;
+      if (depth === 0) {
+        endIndex = i;
+        break;
+      }
+    }
+  }
+
+  if (depth !== 0) {
+    return { hasDateRange: false };
+  }
+
+  const interfaceBody = combinedContent.slice(startIndex, endIndex);
+
+  // bgnDtm/endDtm 패턴 확인
+  const hasBgnDtm = /bgnDtm\s*\??:\s*string/.test(interfaceBody);
+  const hasEndDtm = /endDtm\s*\??:\s*string/.test(interfaceBody);
+
+  if (hasBgnDtm && hasEndDtm) {
+    return {
+      hasDateRange: true,
+      startField: 'bgnDtm',
+      endField: 'endDtm',
+    };
+  }
+
+  // startDateTime/endDateTime 패턴 확인
+  const hasStartDateTime = /startDateTime\s*\??:\s*string/.test(interfaceBody);
+  const hasEndDateTime = /endDateTime\s*\??:\s*string/.test(interfaceBody);
+
+  if (hasStartDateTime && hasEndDateTime) {
+    return {
+      hasDateRange: true,
+      startField: 'startDateTime',
+      endField: 'endDateTime',
+    };
+  }
+
+  return { hasDateRange: false };
+}
+
+// ===== 훅 코드 생성 =====
+
+interface HookMethod {
+  // 공통
+  name: string;
+  functionName: string;
+  requestType: string;
+  responseType: string;
+  dtoType: string;
+
+  // 목록 전용
+  isListMethod: boolean;
+  listName?: string;
+  hasPage: boolean;
+
+  // 단건 전용
+  detailName?: string;
+
+  // dateRange
+  hasDateRange: boolean;
+  dateRangeStartField?: string;
+  dateRangeEndField?: string;
+}
+
+/**
+ * Response 인터페이스에서 ds 필드 타입 추출
+ * PostBannerListBannerResponse → Banner (ds: Banner[])
+ */
+function extractDsFieldType(combinedContent: string, responseType: string): string {
+  if (!responseType || responseType === 'void' || responseType === 'any') {
+    return 'unknown';
+  }
+
+  // Response 인터페이스 찾기
+  const searchStr = `export interface ${responseType}`;
+  const searchIdx = combinedContent.indexOf(searchStr);
+
+  if (searchIdx === -1) {
+    return 'unknown';
+  }
+
+  const afterIdx = searchIdx + searchStr.length;
+  const remaining = combinedContent.slice(afterIdx);
+
+  const match = remaining.match(/^\s*(?:extends\s+[\w<>]+\s*)?\{/);
+  if (!match) {
+    return 'unknown';
+  }
+
+  const startIndex = afterIdx + match[0].length;
+  let depth = 1;
+  let endIndex = startIndex;
+
+  for (let i = startIndex; i < combinedContent.length; i++) {
+    if (combinedContent[i] === '{') {
+      depth++;
+    } else if (combinedContent[i] === '}') {
+      depth--;
+      if (depth === 0) {
+        endIndex = i;
+        break;
+      }
+    }
+  }
+
+  if (depth !== 0) {
+    return 'unknown';
+  }
+
+  const interfaceBody = combinedContent.slice(startIndex, endIndex);
+
+  // ds 필드 찾기
+  const dsMatch = interfaceBody.match(/ds\s*:\s*([\w<>[\]\s]+)(?:\[\])?/);
+  if (dsMatch) {
+    let dsType = dsMatch[1].trim();
+    // 배열 제거 (Banner[] → Banner)
+    dsType = dsType.replace(/\[\]$/, '').trim();
+    // 제네릭 제거
+    dsType = dsType.replace(/<[^>]+>/, '').trim();
+    return dsType;
+  }
+
+  // rs 필드 찾기 (단건)
+  const rsMatch = interfaceBody.match(/rs\s*:\s*([\w<>[\]\s]+)/);
+  if (rsMatch) {
+    let rsType = rsMatch[1].trim();
+    rsType = rsType.replace(/<[^>]+>/, '').trim();
+    return rsType;
+  }
+
+  return 'unknown';
+}
+
+/**
+ * 훅 코드 생성
+ */
+async function generateHookCode(analysis: InterfaceAnalysis, interfacePath: string): Promise<string> {
+  const entityName = analysis.entityName || analysis.className?.replace('Repository', '') || 'Generated';
+  const serviceName = analysis.serviceName || 'GeneratedService';
+  const hookName = `use${entityName}Service`;
+
+  // Repository 파일 읽기 (Response 인터페이스 파싱용)
+  let combinedContent = '';
+  try {
+    const repoContent = await fs.readFile(interfacePath, 'utf-8');
+
+    // Interface 파일 경로 찾기
+    const interfaceDir = path.dirname(interfacePath);
+    const interfaceFilePath = path.join(interfaceDir, '../interface', `${entityName}Interface.ts`);
+
+    let interfaceContent = '';
+    try {
+      interfaceContent = await fs.readFile(interfaceFilePath, 'utf-8');
+    } catch {
+      // Interface 파일이 없으면 skip
+    }
+
+    combinedContent = repoContent + '\n' + interfaceContent;
+  } catch {
+    // 파일 읽기 실패 시 빈 내용
+  }
+
+  // 1. 필터링: 포함/제외 키워드로 메서드 필터링
+  const filteredMethods = analysis.methods.filter(shouldIncludeMethod);
+
+  if (filteredMethods.length === 0) {
+    return `// 생성할 훅 메서드가 없습니다.\n// 포함 키워드: ${INCLUDE_KEYWORDS.join(', ')}\n// 제외 키워드: ${EXCLUDE_KEYWORDS.join(', ')}`;
+  }
+
+  // 2. 메서드 분류 및 네이밍
+  const processedMethods: ProcessedMethod[] = [];
+
+  for (const method of filteredMethods) {
+    // Response 인터페이스에서 ds 필드 타입 추출
+    const dtoType = combinedContent
+      ? extractDsFieldType(combinedContent, method.responseType || '')
+      : extractDtoType(method.responseType || '');
+
+    // Request 타입에서 dateRange 패턴 추출을 위해 combinedContent 필요
+    // 분석 단계에서 이미 dateRangeFields가 있으면 사용
+    const hasDateRange = analysis.hasDateRange || false;
+    const dateRangeFields = analysis.dateRangeFields;
+
+    if (method.responseListField) {
+      // 목록 메서드
+      const listName = extractListName(method.name, entityName);
+      const functionName = extractListFunctionName(method.name, entityName);
+
+      processedMethods.push({
+        method,
+        listName,
+        functionName,
+      });
+    } else if (method.responseDetailField) {
+      // 단건 메서드
+      const detailName = extractDetailName(method.name, entityName);
+      const functionName = extractDetailFunctionName(method.name, entityName);
+
+      processedMethods.push({
+        method,
+        detailName,
+        functionName,
+      });
+    }
+  }
+
+  // 3. 중복 처리 (옵션 C)
+  const resolvedMethods = resolveDuplicateNames(processedMethods, entityName);
+
+  // 4. HookMethod 배열 생성 (DTO 타입 재추출)
+  const hookMethods: HookMethod[] = resolvedMethods.map(pm => {
+    // Response 인터페이스에서 ds 필드 타입 추출
+    const dtoType = combinedContent
+      ? extractDsFieldType(combinedContent, pm.method.responseType || '')
+      : extractDtoType(pm.method.responseType || '');
+    const hasPage = pm.method.hasPage || false;
+
+    // dateRange 정보
+    const hasDateRange = analysis.hasDateRange || false;
+    const dateRangeFields = analysis.dateRangeFields;
+
+    return {
+      name: pm.method.name,
+      functionName: pm.functionName,
+      requestType: pm.method.requestType || 'any',
+      responseType: pm.method.responseType || 'any',
+      dtoType,
+      isListMethod: !!pm.listName,
+      listName: pm.listName,
+      hasPage,
+      detailName: pm.detailName,
+      hasDateRange,
+      dateRangeStartField: dateRangeFields?.startField,
+      dateRangeEndField: dateRangeFields?.endField,
+    };
+  });
+
+  // 5. 코드 생성
+  const lines: string[] = [];
+
+  // Import 수집
+  const requestTypes = new Set<string>();
+  const dtoTypes = new Set<string>();
+
+  for (const hm of hookMethods) {
+    if (hm.requestType && hm.requestType !== 'any' && hm.requestType !== 'void') {
+      requestTypes.add(hm.requestType);
+    }
+    if (hm.dtoType && hm.dtoType !== 'unknown') {
+      dtoTypes.add(hm.dtoType);
+    }
+  }
+
+  // Imports
+  lines.push('import { AXDGPage } from "@axboot/datagrid";');
+  lines.push('import { useCallback, useState } from "react";');
+  lines.push(`import { ${serviceName} } from "services";`);
+  lines.push('import { errorHandling } from "utils";');
+  lines.push('import { deleteEmptyValue } from "@core/utils/object";');
+
+  // Request 타입 import
+  if (requestTypes.size > 0) {
+    const sortedRequestTypes = Array.from(requestTypes).sort();
+    lines.push(`import { ${sortedRequestTypes.join(', ')} } from "services/@interface/interface";`);
+  }
+
+  // DTO 타입 import
+  if (dtoTypes.size > 0) {
+    const sortedDtoTypes = Array.from(dtoTypes).sort();
+    lines.push(`import { ${sortedDtoTypes.join(', ')} } from "services/@interface/dto";`);
+  }
+
+  // dateRange가 있으면 dateRangeToDts import
+  const anyHasDateRange = hookMethods.some(m => m.hasDateRange);
+  if (anyHasDateRange) {
+    lines.push('import { dateRangeToDts } from "utils/dateRangeToDts";');
+    lines.push('import { DT_FORMAT } from "@types";');
+  }
+
+  lines.push('');
+
+  // Hook 함수 선언
+  lines.push(`export function ${hookName}(params?: any) {`);
+
+  // ===== 상태 선언 =====
+  lines.push('  // ===== States =====');
+
+  for (const hm of hookMethods) {
+    if (hm.isListMethod) {
+      // 목록 상태
+      const listName = hm.listName || 'list';
+      lines.push(`  const [${listName}, set${capitalize(listName)}] = useState<${hm.dtoType}[]>([]);`);
+      lines.push(`  const [${listName}Spinning, set${capitalize(listName)}Spinning] = useState(false);`);
+
+      // 페이징 상태 (hasPage: true인 경우만)
+      if (hm.hasPage) {
+        const pageName = listName === 'list' ? 'page' : `${listName}Page`;
+        const setPageName = listName === 'list' ? 'setPage' : `set${capitalize(listName)}Page`;
+        lines.push(`  const [${pageName}, ${setPageName}] = useState<AXDGPage>({`);
+        lines.push(`    totalPages: 0,`);
+        lines.push(`    totalElements: 0,`);
+        lines.push(`    currentPage: 0,`);
+        lines.push(`    pageSize: 0,`);
+        lines.push(`  });`);
+      }
+    } else {
+      // 단건 상태
+      const detailName = hm.detailName || 'detail';
+      lines.push(`  const [${detailName}, set${capitalize(detailName)}] = useState<${hm.dtoType}>();`);
+      lines.push(`  const [${detailName}Spinning, set${capitalize(detailName)}Spinning] = useState(false);`);
+    }
+  }
+
+  lines.push('');
+
+  // ===== 함수 선언 =====
+  lines.push('  // ===== Functions =====');
+
+  for (const hm of hookMethods) {
+    // Request 타입 결정 (void인 경우 Partial 제거)
+    let baseParamType: string;
+    if (hm.requestType && hm.requestType !== 'any' && hm.requestType !== 'void') {
+      baseParamType = `Partial<${hm.requestType}>`;
+    } else if (hm.requestType === 'void') {
+      baseParamType = 'void';
+    } else {
+      baseParamType = 'any';
+    }
+
+    // dateRange가 있으면 intersection type으로 추가 (void가 아닐 때만)
+    const fullParamType = hm.hasDateRange && baseParamType !== 'void'
+      ? `(${baseParamType} & { dateRange?: [string, string] })`
+      : baseParamType;
+
+    // void인 경우 파라미터 없음
+    const paramDef = baseParamType === 'void'
+      ? ''
+      : `${hm.isListMethod ? 'listParams' : 'detail'}: ${fullParamType}`;
+
+    lines.push(`  const ${hm.functionName} = useCallback(async (${paramDef}) => {`);
+
+    if (hm.isListMethod) {
+      const listName = hm.listName || 'list';
+      lines.push(`    set${capitalize(listName)}Spinning(true);`);
+    } else {
+      const detailName = hm.detailName || 'detail';
+      lines.push(`    set${capitalize(detailName)}Spinning(true);`);
+    }
+
+    lines.push('    try {');
+
+    // void 파라미터 처리
+    const isVoidParam = hm.requestType === 'void';
+    const paramVar = hm.isListMethod ? 'listParams' : 'detail';
+
+    // dateRange 변환 처리
+    if (hm.hasDateRange && hm.dateRangeStartField && hm.dateRangeEndField) {
+      const requestType = hm.requestType && hm.requestType !== 'any' && hm.requestType !== 'void'
+        ? ` as ${hm.requestType}`
+        : '';
+      lines.push(`      const data = await ${serviceName}.${hm.name}(deleteEmptyValue({`);
+      lines.push(`        ...${paramVar},`);
+      lines.push(`        ...dateRangeToDts(${paramVar}.dateRange, {`);
+      lines.push(`          ${hm.dateRangeStartField}: DT_FORMAT.DATETIME_HHMMSS,`);
+      lines.push(`          ${hm.dateRangeEndField}: DT_FORMAT.DATETIME_HHMMSS,`);
+      lines.push(`        }),`);
+      lines.push(`      })${requestType});`);
+    } else {
+      if (isVoidParam) {
+        lines.push(`      const data = await ${serviceName}.${hm.name}();`);
+      } else {
+        const requestType = hm.requestType && hm.requestType !== 'any' && hm.requestType !== 'void'
+          ? ` as ${hm.requestType}`
+          : '';
+        lines.push(`      const data = await ${serviceName}.${hm.name}(deleteEmptyValue(${paramVar})${requestType});`);
+      }
+    }
+
+    if (hm.isListMethod) {
+      // 목록: data.ds 사용
+      const listName = hm.listName || 'list';
+      const responseField = listName === 'list' ? 'ds' : 'ds'; // 항상 ds 사용
+      lines.push(`      set${capitalize(listName)}(data.${responseField});`);
+
+      // 페이징 처리 (hasPage: true인 경우만)
+      if (hm.hasPage) {
+        const pageName = listName === 'list' ? 'page' : `${listName}Page`;
+        const setPageName = listName === 'list' ? 'setPage' : `set${capitalize(listName)}Page`;
+        lines.push(`      ${setPageName}({`);
+        lines.push(`        totalPages: data.page.pageCount,`);
+        lines.push(`        totalElements: data.page.totalCount,`);
+        lines.push(`        currentPage: data.page.pageNumber,`);
+        lines.push(`        pageSize: data.page.pageSize,`);
+        lines.push(`      });`);
+      }
+    } else {
+      // 단건: data.rs 사용
+      const detailName = hm.detailName || 'detail';
+      lines.push(`      set${capitalize(detailName)}(data.rs);`);
+    }
+
+    lines.push('    } catch (err) {');
+    lines.push('      await errorHandling(err);');
+    lines.push('    } finally {');
+
+    if (hm.isListMethod) {
+      const listName = hm.listName || 'list';
+      lines.push(`      set${capitalize(listName)}Spinning(false);`);
+    } else {
+      const detailName = hm.detailName || 'detail';
+      lines.push(`      set${capitalize(detailName)}Spinning(false);`);
+    }
+
+    lines.push('    }');
+    lines.push('  }, []);');
+    lines.push('');
+  }
+
+  // ===== 옵션: 자동 초기화 (주석 처리) =====
+  lines.push('  // ===== 옵션: 자동 초기화 (필요시 주석 해제) =====');
+  lines.push('  // React.useEffect(() => {');
+  lines.push('  //   (async () => {');
+  if (hookMethods.length > 0 && hookMethods[0].isListMethod) {
+    lines.push(`  //     await ${hookMethods[0].functionName}(params);`);
+  }
+  lines.push('  //   })();');
+  lines.push('  // }, [params]);');
+  lines.push('  // ===============================================');
+  lines.push('');
+
+  // ===== return =====
+  lines.push('  return {');
+
+  for (const hm of hookMethods) {
+    if (hm.isListMethod) {
+      lines.push(`    ${hm.listName},`);
+      // 페이징 (hasPage: true인 경우만)
+      if (hm.hasPage) {
+        const pageName = hm.listName === 'list' ? 'page' : `${hm.listName}Page`;
+        lines.push(`    ${pageName},`);
+      }
+      lines.push(`    ${hm.listName}Spinning,`);
+      lines.push(`    ${hm.functionName},`);
+    } else {
+      lines.push(`    ${hm.detailName},`);
+      lines.push(`    ${hm.detailName}Spinning,`);
+      lines.push(`    ${hm.functionName},`);
+    }
+  }
+
+  lines.push('  };');
+  lines.push('}');
+
+  return lines.join('\n');
+}
+
+/**
+ * 첫 글자 대문자화
+ */
+function capitalize(str: string): string {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+/**
+ * 훅 생성 (타입 체크 포함)
+ */
+export async function generateHook(args: {
+  interfacePath: string;
+  outputPath?: string;
+}) {
+  const { interfacePath, outputPath } = args;
+
+  try {
+    // 1. 인터페이스 분석
+    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 analysis: InterfaceAnalysis = analyzeData;
+
+    // 2. 기본 경로 설정
+    const entityName = analysis.entityName || analysis.className?.replace('Repository', '') || 'Generated';
+    const finalPath = outputPath || path.join('src', 'hooks', `use${entityName}Service.ts`);
+
+    // 3. 훅 코드 생성
+    const hookCode = await generateHookCode(analysis, interfacePath);
+    await fs.writeFile(finalPath, hookCode, 'utf-8');
+
+    // 4. 타입 체크 (최대 3회 시도)
+    const maxRetries = 3;
+    let typeErrors: string[] = [];
+    let aiFixed = false;
+
+    for (let i = 0; i < maxRetries; i++) {
+      const result = await typeCheck(finalPath);
+
+      if (result.success) {
+        break;
+      }
+
+      typeErrors = result.errors || [];
+
+      if (i === maxRetries - 1) {
+        break;
+      }
+
+      // 1차 시도: AI 자동 수정
+      if (i === 0) {
+        console.log(`[AI 자동 수정] 타입 오류 ${typeErrors.length}건`);
+        // TODO: AI 기반 수정 로직
+        aiFixed = true;
+      }
+    }
+
+    // 5. Lint 및 Prettier
+    await runLintAndPrettier(finalPath);
+
+    // 6. index.ts 자동 생성 및 export 추가
+    const outputDir = path.dirname(finalPath);
+    const indexPath = path.join(outputDir, 'index.ts');
+
+    try {
+      let indexContent = '';
+      try {
+        indexContent = await fs.readFile(indexPath, 'utf-8');
+      } catch {
+        // 파일이 없으면 빈 내용으로 생성
+      }
+
+      const fileName = path.basename(finalPath, '.ts');
+      const exportLine = `export * from './${fileName}';`;
+
+      // 이미 export가 있는지 확인
+      if (!indexContent.includes(exportLine)) {
+        if (indexContent.trim() && !indexContent.trim().endsWith('\n')) {
+          indexContent += '\n';
+        }
+        indexContent += exportLine + '\n';
+        await fs.writeFile(indexPath, indexContent, 'utf-8');
+      }
+    } catch {
+      // index.ts 생성 실패는 무시
+    }
+
+    // 7. 결과 반환
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          success: true,
+          message: typeErrors.length > 0
+            ? `Hook 파일 생성 완료 (타입 오류 ${typeErrors.length}건${aiFixed ? ', AI 수정 후 실패' : ''})`
+            : 'Hook 파일 생성 완료 (타입 체크 통과)',
+          path: finalPath,
+          typeErrors: typeErrors.length > 0 ? typeErrors : undefined,
+          aiFixed: aiFixed,
+        }),
+      }],
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+        }),
+      }],
+    };
+  }
+}