@axboot-mcp/mcp-server 1.0.0

package/src/docs/HOOK_GENERATION_PLAN.md

@@ -0,0 +1,2226 @@
+# React Hook 자동 생성 기능 계획서
+
+## 개요
+
+리포지토리 인터페이스를 분석하여 리액트 훅 파일을 자동 생성하는 MCP 툴을 추가합니다.
+
+---
+
+## 1. 기능 목표
+
+### 1.0 선행 작업: 인터페이스 타입 분석 (최우선)
+
+훅 생성을 위해 **반드시** 인터페이스 파일을 분석하여 요청/응답 타입을 확인해야 합니다.
+
+**분석 순서:**
+1. Repository 파일에서 메서드 추출
+2. 각 메서드의 요청 타입(`RequestType`) 추출
+3. 각 메서드의 응답 타입(`ResponseType`) 추출
+4. 응답 타입에서 DTO 타입 추출 (`ds: Type[]` → `Type`)
+5. 페이징 여부 확인 (`page:` 필드 존재 여부)
+6. dateRange 패턴 확인 (`bgnDtm/endDtm` 쌍)
+
+**타입 추출 예시:**
+```typescript
+// Repository 파일
+async postMemberListMember(params: PostMemberListMemberRequest): Promise<PostMemberListMemberResponse>
+
+// 분석 결과
+{
+  methodName: "postMemberListMember",
+  requestType: "PostMemberListMemberRequest",
+  responseType: "PostMemberListMemberResponse",
+  dtoType: "MemberRes",           // Response에서 ds: MemberRes[] 추출
+  hasPage: true,                  // Response에 page: 필드 있음
+  hasDateRange: true,             // Request에 bgnDtm/endDtm 쌍 있음
+  dateRangeFields: { startField: "bgnDtm", endField: "endDtm" }
+}
+```
+
+### 1.1 대상 API 필터링
+
+| 포함 키워드 | 제외 키워드 |
+|-------------|-------------|
+| 조회, 목록 | 저장, 삭제, 수정, 엑셀, 업로드, 다운로드 |
+
+**예시:**
+```typescript
+/* 회원 목록 */        // ✅ 포함
+async postMemberListMember()  // ✅ 포함
+/* 회원 저장 */        // ❌ 제외
+async postMemberSave()        // ❌ 제외
+/* 엑셀 다운로드 */    // ❌ 제외
+async postMemberExcel()       // ❌ 제외
+```
+
+### 1.2 생성되는 훅 구조
+
+**핵심 원칙:** 각 메서드의 응답 타입을 분석하여 `hasPage` 여부에 따라 **가변적으로** `page`, `setPage`를 생성합니다.
+
+#### Case 1: 페이징 있는 경우
+
+```typescript
+export function useMemberService(params?: ListRequest) {
+  // 상태
+  const [list, setList] = useState<MemberRes[]>([]);
+  const [listSpinning, setListSpinning] = useState(false);
+
+  // ✅ 페이징 있는 경우 (hasPage: true)
+  const [page, setPage] = useState<AXDGPage>({
+    totalPages: 0,
+    totalElements: 0,
+    currentPage: 0,
+    pageSize: 0,
+  });
+
+  // dateRange 있는 경우
+  interface ListRequest extends Partial<PostMemberListMemberRequest> {
+    dateRange?: [string, string];
+  }
+
+  const getList = useCallback(async (listParams: ListRequest) => {
+    setListSpinning(true);
+    try {
+      const data = await MemberService.postMemberListMember(deleteEmptyValue(listParams));
+      setList(data.ds);
+
+      // ✅ hasPage: true이면 setPage 호출
+      setPage({
+        totalPages: data.page.pageCount,
+        totalElements: data.page.totalCount,
+        currentPage: data.page.pageNumber,
+        pageSize: data.page.pageSize,
+      });
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setListSpinning(false);
+    }
+  }, []);
+
+  // ✅ hasPage: true이면 return에 page 포함
+  return {
+    list,
+    page,           // ✅ 포함
+    listSpinning,
+    getList,
+  };
+}
+```
+
+#### Case 2: 페이징 없는 경우
+
+```typescript
+export function useCodeService() {
+  const [list, setList] = useState<Code[]>([]);
+  const [listSpinning, setListSpinning] = useState(false);
+
+  // ❌ 페이징 없으면 page, setPage 생성 안 함
+
+  const getList = useCallback(async (params?: GetCodeListRequest) => {
+    setListSpinning(true);
+    try {
+      const data = await CodeService.getCodeList(deleteEmptyValue(params));
+      setList(data.ds);
+
+      // ❌ hasPage: false이면 setPage 호출 안 함
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setListSpinning(false);
+    }
+  }, []);
+
+  // ❌ hasPage: false이면 return에 page 미포함
+  return {
+    list,
+    // page,       // ❌ 미포함
+    listSpinning,
+    getList,
+  };
+}
+```
+
+#### Case 3: 여러 API - 페이징 섞인 경우
+
+```typescript
+export function useMemberService() {
+  // 첫 번째: 페이징 있음
+  const [list, setList] = useState<MemberRes[]>([]);
+  const [listSpinning, setListSpinning] = useState(false);
+  const [page, setPage] = useState<AXDGPage>({...});  // ✅ 있음
+
+  // 두 번째: 페이징 없음
+  const [adminList, setAdminList] = useState<AdminRes[]>([]);
+  const [adminSpinning, setAdminSpinning] = useState(false);
+  // ❌ adminPage, setAdminPage 없음
+
+  const getList = useCallback(async (params?: ListRequest) => {
+    setListSpinning(true);
+    try {
+      const data = await MemberService.postMemberListMember(deleteEmptyValue(params));
+      setList(data.ds);
+      setPage({ ... });  // ✅ setPage 호출
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setListSpinning(false);
+    }
+  }, []);
+
+  const getAdminList = useCallback(async (params?: AdminListRequest) => {
+    setAdminSpinning(true);
+    try {
+      const data = await MemberService.postMemberListAdmin(deleteEmptyValue(params));
+      setAdminList(data.ds);
+      // ❌ setPage 없음
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setAdminSpinning(false);
+    }
+  }, []);
+
+  return {
+    list,
+    page,           // ✅ 첫 번째는 포함
+    listSpinning,
+    getList,
+    adminList,
+    // adminPage,    // ❌ 두 번째는 미포함
+    adminSpinning,
+    getAdminList,
+  };
+}
+```
+
+---
+
+## 2. 여러 목록 API 처리
+
+### 2.1 네이밍 규칙 (옵션 1: 메서드명 기반 자동 네이밍)
+
+| 메서드명 | 리스트 변수명 | 함수명 |
+|----------|---------------|--------|
+| `postMemberListMember` | `list` (기본) | `getList` |
+| `postMemberListAdmin` | `adminList` | `getAdminList` |
+| `postMemberListActive` | `activeList` | `getActiveList` |
+| `postMemberListByStatus` | `byStatusList` | `getByStatusList` |
+| `postCategoryList` | `categoryList` | `getCategoryList` |
+
+**규칙:**
+- `post{Entity}List{Suffix}` → `{suffix}List` (camelCase)
+- `post{Entity}List` (접미사 없음) → `list` (기본)
+
+### 2.2 여러 API가 있는 경우 생성 예시
+
+**중요:** 각 메서드별로 `hasPage` 여부를 확인하여 **가변적으로** `page`, `setPage`를 생성합니다.
+
+```typescript
+export function useMemberService() {
+  // 첫 번째 목록 (기본) - 페이징 있음 (hasPage: true)
+  const [list, setList] = useState<MemberRes[]>([]);
+  const [listSpinning, setListSpinning] = useState(false);
+  const [page, setPage] = useState<AXDGPage>({...});  // ✅ 있음
+
+  // 두 번째 목록 - 페이징 없음 (hasPage: false)
+  const [adminList, setAdminList] = useState<AdminRes[]>([]);
+  const [adminSpinning, setAdminSpinning] = useState(false);
+  // ❌ adminPage, setAdminPage 없음
+
+  // 세 번째 목록 - 페이징 있음 (hasPage: true)
+  const [activeList, setActiveList] = useState<ActiveRes[]>([]);
+  const [activeSpinning, setActiveSpinning] = useState(false);
+  const [activePage, setActivePage] = useState<AXDGPage>({...});  // ✅ 있음
+
+  // 각각의 getList 함수
+  const getList = useCallback(async (params?: ListRequest) => {
+    setListSpinning(true);
+    try {
+      const data = await MemberService.postMemberListMember(deleteEmptyValue(params));
+      setList(data.ds);
+      setPage({  // ✅ hasPage: true이면 호출
+        totalPages: data.page.pageCount,
+        totalElements: data.page.totalCount,
+        currentPage: data.page.pageNumber,
+        pageSize: data.page.pageSize,
+      });
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setListSpinning(false);
+    }
+  }, []);
+
+  const getAdminList = useCallback(async (params?: AdminListRequest) => {
+    setAdminSpinning(true);
+    try {
+      const data = await MemberService.postMemberListAdmin(deleteEmptyValue(params));
+      setAdminList(data.ds);
+      // ❌ hasPage: false이면 setPage 없음
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setAdminSpinning(false);
+    }
+  }, []);
+
+  const getActiveList = useCallback(async (params?: ActiveListRequest) => {
+    setActiveSpinning(true);
+    try {
+      const data = await MemberService.postMemberListActive(deleteEmptyValue(params));
+      setActiveList(data.ds);
+      setActivePage({  // ✅ hasPage: true이면 호출
+        totalPages: data.page.pageCount,
+        totalElements: data.page.totalCount,
+        currentPage: data.page.pageNumber,
+        pageSize: data.page.pageSize,
+      });
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setActiveSpinning(false);
+    }
+  }, []);
+
+  return {
+    list,
+    page,           // ✅ hasPage: true
+    listSpinning,
+    getList,
+    adminList,
+    // adminPage,    // ❌ hasPage: false
+    adminSpinning,
+    getAdminList,
+    activeList,
+    activePage,     // ✅ hasPage: true
+    activeSpinning,
+    getActiveList,
+  };
+}
+```
+
+**페이징 처리 규칙:**
+| 메서드 | hasPage | 상태 생성 | setPage 호출 | return 포함 |
+|--------|---------|-----------|--------------|-------------|
+| getList | true | ✅ | ✅ | ✅ |
+| getAdminList | false | ❌ | ❌ | ❌ |
+| getActiveList | true | ✅ | ✅ | ✅ |
+
+### 2.3 단건(Detail) API 네이밍 규칙
+
+**메서드 패턴 분류:**
+
+| 구분 | 메서드 패턴 | 예시 | 응답 구조 |
+|------|-------------|------|-----------|
+| 목록 | `post{Entity}List{Suffix}` | `postMemberListMember` | `ds: Type[]` |
+| 단건 | `post{Entity}{Suffix}` | `postMemberDetail`, `postMemberInfo` | `rs: Type` |
+| 단건 | `get{Entity}{Suffix}` | `getMemberDetail`, `getMemberInfo` | `rs: Type` |
+| 단건 | `post{Entity}` | `postMember` | `rs: Type` |
+| 단건 | `get{Entity}` | `getMember` | `rs: Type` |
+
+**단건 네이밍 규칙:**
+
+| 메서드명 | 변수명 | 함수명 | Spinning |
+|----------|--------|--------|----------|
+| `postMemberDetail` | `detail` | `getDetail` | `detailSpinning` |
+| `postMemberInfo` | `info` | `getInfo` | `infoSpinning` |
+| `postMemberProfile` | `profile` | `getProfile` | `profileSpinning` |
+| `postMember` | `member` | `getMember` | `memberSpinning` |
+| `getMemberDetail` | `detail` | `getDetail` | `detailSpinning` |
+| `getMember` | `member` | `getMember` | `memberSpinning` |
+
+**단건 네이밍 추출 로직:**
+
+```typescript
+/**
+ * 메서드명에서 단건 변수명 추출
+ * postMemberDetail → detail
+ * postMemberInfo → info
+ * postMemberProfile → profile
+ * 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
+ * postMemberProfile → getProfile
+ * getMember → getMember
+ */
+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);
+}
+```
+
+### 2.4 중복 처리 규칙 (옵션 C: 중복 시만 구분)
+
+**중복 발생 예시:**
+
+```typescript
+// 중복 가능성
+async postMemberDetail(...)  // → detail, getDetail
+async getMemberDetail(...)   // → detail, getDetail  (중복!)
+```
+
+**중복 처리 로직:**
+
+```typescript
+/**
+ * 중복 확인 후 접두사 추가
+ * 1. 기본 네이밍으로 모든 메서드의 이름을 생성
+ * 2. 중복이 있는 메서드에만 접두사 추가 (post → post, get → get)
+ */
+function resolveDuplicates(methods: Method[]): Method[] {
+  const nameMap = new Map<string, Method[]>();
+
+  // 1. 기본 네이밍으로 이름 생성
+  methods.forEach(method => {
+    const baseName = extractDetailName(method.name, entityName);
+    if (!nameMap.has(baseName)) {
+      nameMap.set(baseName, []);
+    }
+    nameMap.get(baseName)!.push(method);
+  });
+
+  // 2. 중복이 있는 경우 접두사 추가
+  nameMap.forEach((duplicates, baseName) => {
+    if (duplicates.length > 1) {
+      // 중복이 있으면 접두사 추가
+      duplicates.forEach(method => {
+        const prefix = method.name.startsWith('post') ? 'post' : 'get';
+        method.variableName = prefix + baseName.charAt(0).toUpperCase() + baseName.slice(1);
+        method.functionName = 'get' + method.variableName.charAt(0).toUpperCase() + method.variableName.slice(1);
+      });
+    }
+  });
+
+  return methods;
+}
+```
+
+**중복 처리 결과:**
+
+| 메서드명 | 기본 네이밍 | 중복处理后 |
+|----------|-------------|-----------|
+| `postMemberDetail` | `detail`, `getDetail` | `postDetail`, `getPostDetail` |
+| `getMemberDetail` | `detail`, `getDetail` | `detail`, `getDetail` |
+| `postMemberInfo` | `info`, `getInfo` | `info`, `getInfo` (중복 없음) |
+
+### 2.5 목록과 단건 혼합 예시
+
+**입력:**
+```typescript
+// MemberRepository.ts
+
+/* 목록 API */
+async postMemberListMember(...) : Promise<PostMemberListMemberResponse>
+// Response: { ds: MemberRes[]; page: {...} }  → 목록, hasPage: true
+
+async postMemberListAdmin(...) : Promise<PostMemberListAdminResponse>
+// Response: { ds: AdminRes[]; }  → 목록, hasPage: false
+
+/* 단건 API */
+async postMemberDetail(...) : Promise<PostMemberDetailResponse>
+// Response: { rs: MemberDetailRes; }  → 단건
+
+async postMemberInfo(...) : Promise<PostMemberInfoResponse>
+// Response: { rs: MemberInfoRes; }  → 단건
+
+async postMemberProfile(...) : Promise<PostMemberProfileResponse>
+// Response: { rs: MemberProfileRes; }  → 단건
+
+async getMember(...) : Promise<GetMemberResponse>
+// Response: { rs: MemberRes; }  → 단건
+```
+
+**생성되는 훅:**
+
+```typescript
+export function useMemberService() {
+  // ===== 목록 (List) =====
+  const [list, setList] = useState<MemberRes[]>([]);
+  const [listSpinning, setListSpinning] = useState(false);
+  const [page, setPage] = useState<AXDGPage>({...});  // ✅ hasPage: true
+
+  const [adminList, setAdminList] = useState<AdminRes[]>([]);
+  const [adminSpinning, setAdminSpinning] = useState(false);
+  // ❌ adminPage 없음 (hasPage: false)
+
+  // ===== 단건 (Detail) =====
+  const [detail, setDetail] = useState<MemberDetailRes>();
+  const [detailSpinning, setDetailSpinning] = useState(false);
+
+  const [info, setInfo] = useState<MemberInfoRes>();
+  const [infoSpinning, setInfoSpinning] = useState(false);
+
+  const [profile, setProfile] = useState<MemberProfileRes>();
+  const [profileSpinning, setProfileSpinning] = useState(false);
+
+  const [member, setMember] = useState<MemberRes>();
+  const [memberSpinning, setMemberSpinning] = useState(false);
+
+  // ===== 목록 함수 =====
+  const getList = useCallback(async (params?: ListRequest) => {
+    setListSpinning(true);
+    try {
+      const data = await MemberService.postMemberListMember(deleteEmptyValue(params));
+      setList(data.ds);
+      setPage({ ... });  // ✅ hasPage: true
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setListSpinning(false);
+    }
+  }, []);
+
+  const getAdminList = useCallback(async (params?: AdminListRequest) => {
+    setAdminSpinning(true);
+    try {
+      const data = await MemberService.postMemberListAdmin(deleteEmptyValue(params));
+      setAdminList(data.ds);
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setAdminSpinning(false);
+    }
+  }, []);
+
+  // ===== 단건 함수 =====
+  const getDetail = useCallback(async (params?: DetailRequest) => {
+    setDetailSpinning(true);
+    try {
+      const data = await MemberService.postMemberDetail(deleteEmptyValue(params));
+      setDetail(data.rs);
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setDetailSpinning(false);
+    }
+  }, []);
+
+  const getInfo = useCallback(async (params?: InfoRequest) => {
+    setInfoSpinning(true);
+    try {
+      const data = await MemberService.postMemberInfo(deleteEmptyValue(params));
+      setInfo(data.rs);
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setInfoSpinning(false);
+    }
+  }, []);
+
+  const getProfile = useCallback(async (params?: ProfileRequest) => {
+    setProfileSpinning(true);
+    try {
+      const data = await MemberService.postMemberProfile(deleteEmptyValue(params));
+      setProfile(data.rs);
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setProfileSpinning(false);
+    }
+  }, []);
+
+  const getMember = useCallback(async (params?: MemberRequest) => {
+    setMemberSpinning(true);
+    try {
+      const data = await MemberService.getMember(deleteEmptyValue(params));
+      setMember(data.rs);
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setMemberSpinning(false);
+    }
+  }, []);
+
+  return {
+    // 목록
+    list,
+    page,           // ✅ hasPage: true
+    listSpinning,
+    getList,
+    adminList,
+    // adminPage,    // ❌ hasPage: false
+    adminSpinning,
+    getAdminList,
+    // 단건
+    detail,
+    detailSpinning,
+    getDetail,
+    info,
+    infoSpinning,
+    getInfo,
+    profile,
+    profileSpinning,
+    getProfile,
+    member,
+    memberSpinning,
+    getMember,
+  };
+}
+```
+
+**목록 vs 단건 차이점:**
+
+| 구분 | 상태 타입 | 응답 필드 | 페이징 |
+|------|-----------|-----------|--------|
+| 목록 | `Type[]` | `data.ds` | `page` 상태 생성 |
+| 단건 | `Type \| undefined` | `data.rs` | 페이지 없음 |
+
+---
+
+## 3. Spinning 상태 관리 (옵션 B: 개별 spinning)
+
+각 목록마다 개별 spinning 상태를 관리합니다.
+
+```typescript
+const [listSpinning, setListSpinning] = useState(false);
+const [adminSpinning, setAdminSpinning] = useState(false);
+const [activeSpinning, setActiveSpinning] = useState(false);
+```
+
+**장점:**
+- 각 API의 로딩 상태를 독립적으로 관리
+- UI에서 정확한 로딩 표시 가능
+
+---
+
+## 4. DateRange 처리
+
+요청 타입에 `bgnDtm/endDtm` 또는 `startDateTime/endDateTime` 쌍이 있는 경우 자동으로 `dateRange` 필드를 추가합니다.
+
+```typescript
+interface ListRequest extends Partial<PostMemberListMemberRequest> {
+  dateRange?: [string, string];
+}
+
+const getList = useCallback(async (listParams: ListRequest) => {
+  setListSpinning(true);
+  try {
+    const data = await MemberService.postMemberListMember(
+      deleteEmptyValue({
+        ...listParams,
+        ...dateRangeToDts(listParams.dateRange, {
+          bgnDtm: DT_FORMAT.DATETIME_HHMMSS,
+          endDtm: DT_FORMAT.DATETIME_HHMMSS,
+        }),
+      }),
+    );
+    setList(data.ds);
+    // ...
+  } catch (err) {
+    await errorHandling(err);
+  } finally {
+    setListSpinning(false);
+  }
+}, []);
+```
+
+---
+
+## 5. 출력 경로 처리
+
+### 5.1 기본 경로
+
+출력 경로를 지정하지 않은 경우 `src/hooks`에 생성합니다.
+
+```
+src/hooks/useMemberService.ts
+src/hooks/useCategoryService.ts
+```
+
+### 5.2 사용자 지정 경로
+
+출력 경로를 지정한 경우 해당 폴더에 생성합니다.
+
+```
+src/hooks/member/useMemberService.ts
+src/hooks/product/useProductService.ts
+```
+
+### 5.3 index.ts 자동 생성
+
+대상 폴더에 `index.ts`가 없으면 자동으로 생성하고 export를 추가합니다.
+
+```typescript
+// src/hooks/index.ts
+export * from './useMemberService';
+export * from './useCategoryService';
+export * from './useProductService';
+```
+
+### 5.4 기존 파일 처리
+
+기존 파일이 있으면 덮어씁니다.
+
+---
+
+## 6. 구현 파일 구조
+
+```
+src/
+├── handlers/
+│   └── generate-hook.ts     # 새로 추가
+├── templates/
+│   └── hook-template.ts     # 새로 추가
+└── index.ts                 # 도구 등록
+```
+
+---
+
+## 7. MCP 도구 사양
+
+### 7.1 도구 이름
+
+`generate-hook`
+
+### 7.2 파라미터
+
+| 파라미터 | 타입 | 필수 | 설명 | 기본값 |
+|----------|------|------|------|--------|
+| `interfacePath` | string | ✅ | 인터페이스 Repository 파일 경로 (절대 경로) | - |
+| `outputPath` | string | ❌ | 생성할 훅 파일 경로 (절대 경로) | `src/hooks/use{Entity}Service.ts` |
+
+### 7.3 사용 예시
+
+```typescript
+// 기본 경로 (src/hooks)
+{
+  "interfacePath": "/path/to/repository/MemberRepository.ts"
+}
+// → src/hooks/useMemberService.ts 생성
+
+// 사용자 지정 경로
+{
+  "interfacePath": "/path/to/repository/MemberRepository.ts",
+  "outputPath": "/path/to/src/hooks/member/useMemberService.ts"
+}
+// → 지정한 경로에 생성
+```
+
+---
+
+## 8. 네이밍 추출 로직
+
+### 8.1 리스트 변수명 추출
+
+```typescript
+/**
+ * 메서드명에서 리스트 변수명 추출
+ * postMemberListMember → memberList (접미사가 Entity면 기본값 list)
+ * 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';
+}
+```
+
+### 8.2 함수명 추출
+
+```typescript
+/**
+ * 메서드명에서 함수명 추출
+ * postMemberListMember → getList (접미사가 Entity면 getList)
+ * postMemberListAdmin → getAdminList
+ * postMemberList → getList
+ */
+function extractFunctionName(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 'getList';
+
+    // 접미사가 Entity명과 같으면 getList
+    if (suffix.toLowerCase() === entityName.toLowerCase()) {
+      return 'getList';
+    }
+
+    // 첫 글자 대문자로 변환 (PascalCase)
+    return 'get' + suffix.charAt(0).toUpperCase() + suffix.slice(1);
+  }
+
+  return 'getList';
+}
+```
+
+### 8.2 단건(Detail) 변수명 추출
+
+```typescript
+/**
+ * 메서드명에서 단건 변수명 추출
+ * 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'; // 기본값
+}
+```
+
+### 8.3 단건(Detail) 함수명 추출
+
+```typescript
+/**
+ * 메서드명에서 단건 함수명 추출
+ * 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);
+}
+```
+
+### 8.4 중복 처리 로직
+
+```typescript
+/**
+ * 중복 확인 후 접두사 추가
+ * 1. 기본 네이밍으로 모든 메서드의 이름을 생성
+ * 2. 중복이 있는 메서드에만 접두사 추가
+ */
+function resolveDuplicateNames(methods: MethodInfo[]): MethodInfo[] {
+  const nameMap = new Map<string, MethodInfo[]>();
+
+  // 1. 기본 네이밍으로 이름 생성 후 그룹화
+  methods.forEach(method => {
+    const baseName = method.isListMethod
+      ? extractListName(method.name, entityName)
+      : extractDetailName(method.name, entityName);
+
+    if (!nameMap.has(baseName)) {
+      nameMap.set(baseName, []);
+    }
+    nameMap.get(baseName)!.push(method);
+  });
+
+  // 2. 중복이 있는 경우 접두사 추가
+  nameMap.forEach((duplicates, baseName) => {
+    if (duplicates.length > 1) {
+      // 중복이 있으면 접두사 추가 (post/get 또는 List/Detail 구분)
+      duplicates.forEach((method, index) => {
+        if (method.isListMethod) {
+          // 목록은 접미사로 구분
+          method.listName = baseName + (index + 1);
+          method.functionName = 'get' + baseName.charAt(0).toUpperCase() + baseName.slice(1) + (index + 1);
+        } else {
+          // 단건은 post/get 접두사로 구분
+          const prefix = method.name.startsWith('post') ? 'post' : 'get';
+          method.detailName = prefix + baseName.charAt(0).toUpperCase() + baseName.slice(1);
+          method.functionName = 'get' + method.detailName.charAt(0).toUpperCase() + method.detailName.slice(1);
+        }
+      });
+    }
+  });
+
+  return methods;
+}
+```
+
+---
+
+## 9. 템플릿 변수
+
+```typescript
+interface HookTemplateVariables {
+  // 서비스 정보
+  serviceName: string;         // MemberService
+  entityName: string;          // Member
+  hookName: string;            // useMemberService
+
+  // 메서드 정보 (목록 + 단건)
+  methods: Array<{
+    // 공통
+    name: string;              // postMemberListMember, postMemberDetail
+    functionName: string;       // getList, getDetail
+    requestType: string;       // PostMemberListMemberRequest, PostMemberDetailRequest
+    responseType: string;      // PostMemberListMemberResponse, PostMemberDetailResponse
+    dtoType: string;           // MemberRes, MemberDetailRes
+
+    // 목록(List) 전용
+    isListMethod: boolean;     // true: 목록, false: 단건
+    listName?: string;         // list, adminList (목록인 경우)
+    hasPage: boolean;          // 페이징 여부 (가변 처리 결정)
+
+    // 단건(Detail) 전용
+    detailName?: string;       // detail, info, member (단건인 경우)
+
+    // dateRange 정보
+    hasDateRange: boolean;
+    dateRangeStartField?: string;  // bgnDtm
+    dateRangeEndField?: string;    // endDtm
+  }>;
+
+  // 분류된 메서드
+  listMethods: typeof methods;   // isListMethod: true인 메서드들
+  detailMethods: typeof methods; // isListMethod: false인 메서드들
+}
+```
+
+### 9.1 목록/단건에 따른 가변 처리 로직
+
+```typescript
+// 템플릿 내부 처리 로직 (pseudo code)
+
+// ===== 목록(List) 메서드 처리 =====
+listMethods.forEach(method => {
+  // 1. 상태 선언
+  const [listName, setListName] = useState<DtoType[]>([]);
+  const [listNameSpinning, setListNameSpinning] = useState(false);
+
+  // 2. 페이징 상태 (hasPage: true인 경우만)
+  if (method.hasPage) {
+    const [page, setPage] = useState<AXDGPage>({...});
+  }
+
+  // 3. useCallback
+  const callback = useCallback(async (params) => {
+    setListNameSpinning(true);
+    try {
+      const data = await Service.method(deleteEmptyValue(params));
+      setListName(data.ds);  // 목록은 data.ds 사용
+
+      if (method.hasPage) {
+        setPage({ ... });  // 가변 처리
+      }
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setListNameSpinning(false);
+    }
+  }, []);
+
+  // 4. return 값
+  if (method.hasPage) {
+    return { listName, page, listNameSpinning, functionName };
+  } else {
+    return { listName, listNameSpinning, functionName };
+  }
+});
+
+// ===== 단건(Detail) 메서드 처리 =====
+detailMethods.forEach(method => {
+  // 1. 상태 선언
+  const [detailName, setDetailName] = useState<DtoType>();
+  const [detailNameSpinning, setDetailNameSpinning] = useState(false);
+
+  // 2. useCallback
+  const callback = useCallback(async (params) => {
+    setDetailNameSpinning(true);
+    try {
+      const data = await Service.method(deleteEmptyValue(params));
+      setDetailName(data.rs);  // 단건은 data.rs 사용
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setDetailNameSpinning(false);
+    }
+  }, []);
+
+  // 3. return 값 (단건은 페이징 없음)
+  return { detailName, detailNameSpinning, functionName };
+});
+```
+
+### 9.2 응답 필드에 따른 분류
+
+```typescript
+/**
+ * 응답 인터페이스에서 필드 구조 분석
+ * data.ds[] → 목록 (isListMethod: true)
+ * data.rs → 단건 (isListMethod: false)
+ */
+function classifyMethodByResponse(responseType: string): 'list' | 'detail' {
+  const responseInterface = findInterface(content, responseType);
+
+  if (responseInterface) {
+    // ds: Type[] 형태 → 목록
+    if (/ds:\s*\w+\[\]/.test(responseInterface)) {
+      return 'list';
+    }
+    // rs: Type 형태 → 단건
+    if (/rs:\s*\w+/.test(responseInterface)) {
+      return 'detail';
+    }
+  }
+
+  return 'list'; // 기본값
+}
+```
+
+---
+
+## 10. 구현 우선순위
+
+### 최우선: 인터페이스 타입 분석
+
+**모든 작업의 선행 조건:**
+1. ✅ 인터페이스 Repository 파일 파싱
+2. ✅ 메서드 추출 (주석, 시그니처)
+3. ✅ 요청 타입(`RequestType`) 추출
+4. ✅ 응답 타입(`ResponseType`) 추출
+5. ✅ 응답 타입에서 DTO 타입 추출 (`ds: Type[]` → `Type`)
+6. ✅ 페이징 여부 확인 (`page:` 필드)
+7. ✅ dateRange 패턴 확인 (`bgnDtm/endDtm` 쌍)
+
+### 이후 작업 순서
+
+1. ✅ 기본 훅 템플릿 생성 (단일 API)
+2. ✅ 여러 API 네이밍 로직 구현
+3. ✅ 개별 spinning 상태 추가
+4. ✅ **hasPage에 따른 가변 처리** (page, setPage)
+5. ✅ dateRange 처리
+6. ✅ 출력 경로 처리 (기본/사용자 지정)
+7. ✅ index.ts 자동 생성 및 export
+8. ✅ 제외 키워드 필터링
+9. ✅ ESLint, Prettier 자동 적용
+
+---
+
+## 11. 테스트 시나리오
+
+### 11.1 페이징 유무에 따른 가변 처리 확인
+
+**입력 (페이징 있음):**
+```typescript
+// MemberRepository.ts
+/* 회원 목록 */
+async postMemberListMember(params: PostMemberListMemberRequest): Promise<PostMemberListMemberResponse>
+
+// Response 인터페이스
+export interface PostMemberListMemberResponse extends DataGridPageResponse {
+  ds: MemberRes[];
+  page: { pageCount: number; totalCount: number; pageNumber: number; pageSize: number; };
+}
+```
+
+**분석 결과:**
+```typescript
+{
+  methodName: "postMemberListMember",
+  hasPage: true,  // ✅ page: 필드 있음
+}
+```
+
+**출력 (페이징 있음):**
+```typescript
+// useMemberService.ts
+export function useMemberService(params?: ListRequest) {
+  const [list, setList] = useState<MemberRes[]>([]);
+  const [listSpinning, setListSpinning] = useState(false);
+  const [page, setPage] = useState<AXDGPage>({...});  // ✅ 있음
+
+  const getList = useCallback(async (listParams: ListRequest) => {
+    setListSpinning(true);
+    try {
+      const data = await MemberService.postMemberListMember(deleteEmptyValue(listParams));
+      setList(data.ds);
+      setPage({ ... });  // ✅ 호출
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setListSpinning(false);
+    }
+  }, []);
+
+  return { list, page, listSpinning, getList };  // ✅ page 포함
+}
+```
+
+---
+
+**입력 (페이징 없음):**
+```typescript
+// CodeRepository.ts
+/* 코드 목록 */
+async getCodeList(params: GetCodeListRequest): Promise<GetCodeListResponse>
+
+// Response 인터페이스
+export interface GetCodeListResponse {
+  ds: Code[];
+  // page: 필드 없음
+}
+```
+
+**분석 결과:**
+```typescript
+{
+  methodName: "getCodeList",
+  hasPage: false,  // ❌ page: 필드 없음
+}
+```
+
+**출력 (페이징 없음):**
+```typescript
+// useCodeService.ts
+export function useCodeService() {
+  const [list, setList] = useState<Code[]>([]);
+  const [listSpinning, setListSpinning] = useState(false);
+  // ❌ page, setPage 없음
+
+  const getList = useCallback(async (params?: GetCodeListRequest) => {
+    setListSpinning(true);
+    try {
+      const data = await CodeService.getCodeList(deleteEmptyValue(params));
+      setList(data.ds);
+      // ❌ setPage 없음
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setListSpinning(false);
+    }
+  }, []);
+
+  return { list, listSpinning, getList };  // ❌ page 미포함
+}
+```
+
+### 11.2 여러 목록 API (페이징 섞인 경우)
+
+**입력:**
+```typescript
+// MemberRepository.ts
+/* 회원 목록 */
+async postMemberListMember(params: PostMemberListMemberRequest): Promise<PostMemberListMemberResponse> { ... }
+// Response: { ds: MemberRes[]; page: {...} }  → hasPage: true
+
+/* 관리자 목록 */
+async postMemberListAdmin(params: PostMemberListAdminRequest): Promise<PostMemberListAdminResponse> { ... }
+// Response: { ds: AdminRes[]; }  → hasPage: false
+
+/* 활성 회원 목록 */
+async postMemberListActive(params: PostMemberListActiveRequest): Promise<PostMemberListActiveResponse> { ... }
+// Response: { ds: ActiveRes[]; page: {...} }  → hasPage: true
+```
+
+**출력 (가변 처리 적용):**
+```typescript
+// useMemberService.ts
+export function useMemberService() {
+  const [list, setList] = useState<MemberRes[]>([]);
+  const [listSpinning, setListSpinning] = useState(false);
+  const [page, setPage] = useState<AXDGPage>({...});  // ✅ 있음 (hasPage: true)
+
+  const [adminList, setAdminList] = useState<AdminRes[]>([]);
+  const [adminSpinning, setAdminSpinning] = useState(false);
+  // ❌ adminPage, setAdminPage 없음 (hasPage: false)
+
+  const [activeList, setActiveList] = useState<ActiveRes[]>([]);
+  const [activeSpinning, setActiveSpinning] = useState(false);
+  const [activePage, setActivePage] = useState<AXDGPage>({...});  // ✅ 있음 (hasPage: true)
+
+  const getList = useCallback(async (params?: ListRequest) => {
+    setListSpinning(true);
+    try {
+      const data = await MemberService.postMemberListMember(deleteEmptyValue(params));
+      setList(data.ds);
+      setPage({ ... });  // ✅ 호출 (hasPage: true)
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setListSpinning(false);
+    }
+  }, []);
+
+  const getAdminList = useCallback(async (params?: AdminListRequest) => {
+    setAdminSpinning(true);
+    try {
+      const data = await MemberService.postMemberListAdmin(deleteEmptyValue(params));
+      setAdminList(data.ds);
+      // ❌ setPage 없음 (hasPage: false)
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setAdminSpinning(false);
+    }
+  }, []);
+
+  const getActiveList = useCallback(async (params?: ActiveListRequest) => {
+    setActiveSpinning(true);
+    try {
+      const data = await MemberService.postMemberListActive(deleteEmptyValue(params));
+      setActiveList(data.ds);
+      setActivePage({ ... });  // ✅ 호출 (hasPage: true)
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setActiveSpinning(false);
+    }
+  }, []);
+
+  return {
+    list,
+    page,           // ✅ 포함 (hasPage: true)
+    listSpinning,
+    getList,
+    adminList,
+    // adminPage,    // ❌ 미포함 (hasPage: false)
+    adminSpinning,
+    getAdminList,
+    activeList,
+    activePage,     // ✅ 포함 (hasPage: true)
+    activeSpinning,
+    getActiveList,
+  };
+}
+```
+
+**페이징 처리 규칙:**
+| 메서드 | hasPage | 상태 생성 | setPage 호출 | return 포함 |
+|--------|---------|-----------|--------------|-------------|
+| getList | true | ✅ | ✅ | ✅ |
+| getAdminList | false | ❌ | ❌ | ❌ |
+| getActiveList | true | ✅ | ✅ | ✅ |
+
+### 11.3 제외 키워드가 포함된 API
+
+**입력:**
+```typescript
+// MemberRepository.ts
+/* 회원 목록 */
+async postMemberListMember(params: PostMemberListMemberRequest): Promise<PostMemberListMemberResponse> { ... }
+// Response: { ds: MemberRes[]; page: {...} }  → hasPage: true
+
+/* 회원 저장 */  // ❌ "저장" 키워드로 제외
+async postMemberSave(params: PostMemberSaveRequest) { ... }
+
+/* 회원 삭제 */  // ❌ "삭제" 키워드로 제외
+async postMemberDelete(params: PostMemberDeleteRequest) { ... }
+
+/* 엑셀 다운로드 */  // ❌ "엑셀", "다운로드" 키워드로 제외
+async postMemberExcel(params: PostMemberExcelRequest) { ... }
+```
+
+**분석 결과:**
+```typescript
+// 포함 API만 필터링
+{
+  includedMethods: [
+    { name: "postMemberListMember", hasPage: true }
+  ],
+  excludedMethods: [
+    { name: "postMemberSave", reason: "저장" },
+    { name: "postMemberDelete", reason: "삭제" },
+    { name: "postMemberExcel", reason: "엑셀, 다운로드" }
+  ]
+}
+```
+
+**출력 (목록/조회 API만 포함):**
+```typescript
+// useMemberService.ts
+export function useMemberService(params?: ListRequest) {
+  const [list, setList] = useState<MemberRes[]>([]);
+  const [listSpinning, setListSpinning] = useState(false);
+  const [page, setPage] = useState<AXDGPage>({...});  // ✅ hasPage: true
+
+  const getList = useCallback(async (listParams: ListRequest) => {
+    setListSpinning(true);
+    try {
+      const data = await MemberService.postMemberListMember(deleteEmptyValue(listParams));
+      setList(data.ds);
+      setPage({ ... });  // ✅ hasPage: true
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setListSpinning(false);
+    }
+  }, []);
+
+  return { list, page, listSpinning, getList };
+}
+
+// ❌ 저장, 삭제, 엑셀 API는 훅에 포함되지 않음
+```
+
+### 11.4 목록과 단건 혼합
+
+**입력:**
+```typescript
+// MemberRepository.ts
+
+/* 목록 API */
+/* 회원 목록 */
+async postMemberListMember(params: PostMemberListMemberRequest): Promise<PostMemberListMemberResponse>
+// Response: { ds: MemberRes[]; page: {...} }  → 목록, hasPage: true
+
+/* 관리자 목록 */
+async postMemberListAdmin(params: PostMemberListAdminRequest): Promise<PostMemberListAdminResponse>
+// Response: { ds: AdminRes[]; }  → 목록, hasPage: false
+
+/* 단건 API */
+/* 회원 상세 */
+async postMemberDetail(params: PostMemberDetailRequest): Promise<PostMemberDetailResponse>
+// Response: { rs: MemberDetailRes; }  → 단건
+
+/* 회원 정보 */
+async postMemberInfo(params: PostMemberInfoRequest): Promise<PostMemberInfoResponse>
+// Response: { rs: MemberInfoRes; }  → 단건
+
+/* 회원 프로필 */
+async postMemberProfile(params: PostMemberProfileRequest): Promise<PostMemberProfileResponse>
+// Response: { rs: MemberProfileRes; }  → 단건
+
+/* 회원 조회 (단건) */
+async getMember(params: GetMemberRequest): Promise<GetMemberResponse>
+// Response: { rs: MemberRes; }  → 단건
+```
+
+**분석 결과:**
+```typescript
+{
+  listMethods: [
+    { name: "postMemberListMember", hasPage: true, listName: "list", functionName: "getList" },
+    { name: "postMemberListAdmin", hasPage: false, listName: "adminList", functionName: "getAdminList" }
+  ],
+  detailMethods: [
+    { name: "postMemberDetail", detailName: "detail", functionName: "getDetail" },
+    { name: "postMemberInfo", detailName: "info", functionName: "getInfo" },
+    { name: "postMemberProfile", detailName: "profile", functionName: "getProfile" },
+    { name: "getMember", detailName: "member", functionName: "getMember" }
+  ]
+}
+```
+
+**출력 (목록 + 단건 혼합):**
+```typescript
+// useMemberService.ts
+export function useMemberService() {
+  // ===== 목록 (List) =====
+  const [list, setList] = useState<MemberRes[]>([]);
+  const [listSpinning, setListSpinning] = useState(false);
+  const [page, setPage] = useState<AXDGPage>({...});  // ✅ hasPage: true
+
+  const [adminList, setAdminList] = useState<AdminRes[]>([]);
+  const [adminSpinning, setAdminSpinning] = useState(false);
+  // ❌ adminPage 없음 (hasPage: false)
+
+  // ===== 단건 (Detail) =====
+  const [detail, setDetail] = useState<MemberDetailRes>();
+  const [detailSpinning, setDetailSpinning] = useState(false);
+
+  const [info, setInfo] = useState<MemberInfoRes>();
+  const [infoSpinning, setInfoSpinning] = useState(false);
+
+  const [profile, setProfile] = useState<MemberProfileRes>();
+  const [profileSpinning, setProfileSpinning] = useState(false);
+
+  const [member, setMember] = useState<MemberRes>();
+  const [memberSpinning, setMemberSpinning] = useState(false);
+
+  // ===== 목록 함수 =====
+  const getList = useCallback(async (params?: ListRequest) => {
+    setListSpinning(true);
+    try {
+      const data = await MemberService.postMemberListMember(deleteEmptyValue(params));
+      setList(data.ds);  // 목록은 data.ds
+      setPage({ ... });  // ✅ hasPage: true
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setListSpinning(false);
+    }
+  }, []);
+
+  const getAdminList = useCallback(async (params?: AdminListRequest) => {
+    setAdminSpinning(true);
+    try {
+      const data = await MemberService.postMemberListAdmin(deleteEmptyValue(params));
+      setAdminList(data.ds);  // 목록은 data.ds
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setAdminSpinning(false);
+    }
+  }, []);
+
+  // ===== 단건 함수 =====
+  const getDetail = useCallback(async (params?: DetailRequest) => {
+    setDetailSpinning(true);
+    try {
+      const data = await MemberService.postMemberDetail(deleteEmptyValue(params));
+      setDetail(data.rs);  // 단건은 data.rs
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setDetailSpinning(false);
+    }
+  }, []);
+
+  const getInfo = useCallback(async (params?: InfoRequest) => {
+    setInfoSpinning(true);
+    try {
+      const data = await MemberService.postMemberInfo(deleteEmptyValue(params));
+      setInfo(data.rs);
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setInfoSpinning(false);
+    }
+  }, []);
+
+  const getProfile = useCallback(async (params?: ProfileRequest) => {
+    setProfileSpinning(true);
+    try {
+      const data = await MemberService.postMemberProfile(deleteEmptyValue(params));
+      setProfile(data.rs);
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setProfileSpinning(false);
+    }
+  }, []);
+
+  const getMember = useCallback(async (params?: MemberRequest) => {
+    setMemberSpinning(true);
+    try {
+      const data = await MemberService.getMember(deleteEmptyValue(params));
+      setMember(data.rs);
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setMemberSpinning(false);
+    }
+  }, []);
+
+  return {
+    // 목록
+    list,
+    page,           // ✅ hasPage: true
+    listSpinning,
+    getList,
+    adminList,
+    // adminPage,    // ❌ hasPage: false
+    adminSpinning,
+    getAdminList,
+    // 단건
+    detail,
+    detailSpinning,
+    getDetail,
+    info,
+    infoSpinning,
+    getInfo,
+    profile,
+    profileSpinning,
+    getProfile,
+    member,
+    memberSpinning,
+    getMember,
+  };
+}
+```
+
+### 11.5 중복 발생 시 처리 예시
+
+**입력 (중복 발생):**
+```typescript
+// MemberRepository.ts
+/* 회원 상세 (post) */
+async postMemberDetail(...) : Promise<PostMemberDetailResponse>
+
+/* 회원 상세 (get) */
+async getMemberDetail(...) : Promise<GetMemberDetailResponse>
+```
+
+**분석 결과 (중복 감지):**
+```typescript
+{
+  duplicates: [
+    { name: "postMemberDetail", baseName: "detail", functionName: "getDetail" },
+    { name: "getMemberDetail", baseName: "detail", functionName: "getDetail" }
+  ]
+}
+```
+
+**출력 (중복 처리 - 옵션 C: 중복 시만 구분):**
+```typescript
+// useMemberService.ts
+export function useMemberService() {
+  // 중복 처리: post 접두사 추가
+  const [postDetail, setPostDetail] = useState<PostMemberDetailRes>();
+  const [postDetailSpinning, setPostDetailSpinning] = useState(false);
+
+  // 중복 없음: 기본 네이밍
+  const [detail, setDetail] = useState<GetMemberDetailRes>();
+  const [detailSpinning, setDetailSpinning] = useState(false);
+
+  const getPostDetail = useCallback(async (params?: PostDetailRequest) => {
+    setPostDetailSpinning(true);
+    try {
+      const data = await MemberService.postMemberDetail(deleteEmptyValue(params));
+      setPostDetail(data.rs);
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setPostDetailSpinning(false);
+    }
+  }, []);
+
+  const getDetail = useCallback(async (params?: DetailRequest) => {
+    setDetailSpinning(true);
+    try {
+      const data = await MemberService.getMemberDetail(deleteEmptyValue(params));
+      setDetail(data.rs);
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setDetailSpinning(false);
+    }
+  }, []);
+
+  return {
+    postDetail,
+    postDetailSpinning,
+    getPostDetail,  // 중복 처리: getPostDetail
+    detail,
+    detailSpinning,
+    getDetail,      // 기본 유지
+  };
+}
+```
+
+---
+
+## 12. 공통 Import
+
+```typescript
+import { AXDGPage } from "@axboot/datagrid";
+import { useCallback, useState } from "react";
+import { {Service}, {ResponseType}, {RequestType} } from "../services";
+import { dateRangeToDts, errorHandling } from "../utils";
+import { deleteEmptyValue } from "../@core/utils/object";
+import { DT_FORMAT } from "../@types";
+```
+
+---
+
+## 13. 추가 고려사항
+
+### 13.1 주석 처리된 옵션 기능 (작업자 판단 후 사용)
+
+**원칙:** 생성 시 아래 내용을 **무조건 주석 처리**하여 포함하고, 작업자가 필요시 주석을 해제하여 사용합니다.
+
+#### 13.1.1 자동 초기화 (주석 처리)
+
+훅 생성 시 마운트 시 자동으로 데이터를 조회하는 코드를 주석 처리하여 포함합니다.
+
+```typescript
+export function useMemberService(params?: ListRequest) {
+  // ... 상태 선언, useCallback 등
+
+  // ===== 옵션: 자동 초기화 (필요시 주석 해제) =====
+  // React.useEffect(() => {
+  //   (async () => {
+  //     await getList(params);
+  //   })();
+  // }, [getList, params]);
+  // ===============================================
+
+  return {
+    list,
+    page,
+    listSpinning,
+    getList,
+  };
+}
+```
+
+**작업자 가이드:**
+- 컴포넌트 마운트 시 자동으로 데이터를 조회하려면 주석 해제
+- `params`가 변경될 때마다 재조회됨
+
+#### 13.1.2 i18n 사용 (주석 처리)
+
+훅 생성 시 i18n 사용 코드를 주석 처리하여 포함합니다.
+
+```typescript
+export function useMemberService(params?: ListRequest) {
+  // ===== 옵션: i18n 사용 (필요시 주석 해제) =====
+  // const { t } = useI18n();
+  // ==============================================
+
+  // ... 상태 선언, useCallback 등
+
+  return {
+    list,
+    page,
+    listSpinning,
+    getList,
+  };
+}
+```
+
+**작업자 가이드:**
+- 다국어 처리가 필요한 경우 주석 해제 후 `t()` 함수 사용
+
+#### 13.1.3 전체 옵션 포함 예시
+
+```typescript
+export function useMemberService(params?: ListRequest) {
+  // ===== 옵션: i18n 사용 (필요시 주석 해제) =====
+  // const { t } = useI18n();
+  // ==============================================
+
+  const [list, setList] = useState<MemberRes[]>([]);
+  const [listSpinning, setListSpinning] = useState(false);
+  const [page, setPage] = useState<AXDGPage>({...});
+
+  const getList = useCallback(async (listParams: ListRequest) => {
+    setListSpinning(true);
+    try {
+      const data = await MemberService.postMemberListMember(deleteEmptyValue(listParams));
+      setList(data.ds);
+      setPage({ ... });
+    } catch (err) {
+      await errorHandling(err);
+    } finally {
+      setListSpinning(false);
+    }
+  }, []);
+
+  // ===== 옵션: 자동 초기화 (필요시 주석 해제) =====
+  // React.useEffect(() => {
+  //   (async () => {
+  //     await getList(params);
+  //   })();
+  // }, [getList, params]);
+  // ===============================================
+
+  return {
+    list,
+    page,
+    listSpinning,
+    getList,
+  };
+}
+```
+
+### 13.2 옵션 기능 포함 여부 결정 기준
+
+| 옵션 | 포함 여부 | 주석 처리 | 비고 |
+|------|-----------|-----------|------|
+| 자동 초기화 | ✅ 항상 포함 | ✅ 주석 처리 | 작업자가 필요 시 해제 |
+| i18n 사용 | ✅ 항상 포함 | ✅ 주석 처리 | 작업자가 필요 시 해제 |
+| 페이징 | ✅ hasPage에 따라 가변 | ❌ 주석 없음 | 자동 생성 |
+| dateRange | ✅ 패턴에 따라 가변 | ❌ 주석 없음 | 자동 생성 |
+
+---
+
+## 14. 타입 체크 및 자동 수정
+
+### 14.1 타입 체크 흐름
+
+```
+1. 훅 파일 생성
+2. 프로젝트 구조 자동 분석 (tsconfig.json, package.json)
+3. 적절한 명령으로 타입 체크 실행 (npm run type-check 또는 npx tsc --noEmit)
+4. 타입 오류가 있으면 AI가 1차 자동 수정 시도
+5. 수정된 코드로 재시도
+6. 그래도 실패하면 사용자에게 위임 (결과에 타입 오류 포함)
+7. 사용자가 판단 후 수정 요청
+```
+
+### 14.2 재시도 로직
+
+| 시도 | 동작 | 실패 시 처리 |
+|------|------|-------------|
+| 1회차 | 기본 생성 후 타입 체크 | AI 자동 수정 |
+| 2회차 | AI 수정 후 타입 체크 | 사용자에게 위임 |
+| 3회차 | (옵션) 재시도 | 사용자에게 위임 |
+
+### 14.2 프로젝트 구조 자동 분석
+
+```typescript
+/**
+ * 프로젝트 루트 찾기 (tsconfig.json이 있는 위치)
+ */
+async function findProjectRoot(startPath: string): Promise<string> {
+  let currentDir = path.dirname(startPath);
+
+  // 최대 10단계 상위 폴더로 탐색
+  for (let i = 0; i < 10; i++) {
+    const tsconfigPath = path.join(currentDir, 'tsconfig.json');
+
+    try {
+      await fs.access(tsconfigPath);
+      return currentDir; // tsconfig.json을 찾으면 해당 경로가 프로젝트 루트
+    } catch {
+      // 상위 폴더로 이동
+      currentDir = path.dirname(currentDir);
+      if (currentDir === path.dirname(currentDir)) break;
+    }
+  }
+
+  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;
+  }
+}
+```
+
+### 14.3 타입 체크 실행
+
+```typescript
+/**
+ * 타입 체크 실행 (프로젝트 구조 자동 분석)
+ */
+async function typeCheck(filePath: string): Promise<{ success: boolean; errors?: string[] }> {
+  try {
+    // 1. 프로젝트 루트 찾기
+    const projectRoot = await findProjectRoot(filePath);
+
+    // 2. package.json의 type-check 스크립트 확인
+    const hasTypeCheck = await hasTypeCheckScript(projectRoot);
+
+    let command: string;
+    let args: string[];
+
+    if (hasTypeCheck) {
+      // package.json에 type-check 스크립트가 있으면 그것 사용
+      command = 'npm';
+      args = ['run', 'type-check'];
+    } else {
+      // 없으면 tsc 직접 실행
+      command = 'npx';
+      args = ['tsc', '--noEmit', filePath];
+    }
+
+    // 3. 명령 실행 (백그라운드)
+    execSync(
+      `${command} ${args.join(' ')}`,
+      {
+        encoding: 'utf-8',
+        cwd: projectRoot,
+        stdio: ['ignore', 'ignore', 'pipe'],
+        timeout: 30000 // 30초 타임아웃
+      }
+    );
+
+    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 };
+  }
+}
+```
+
+### 14.4 결과 반환 (AI 1차 수정 후 사용자 위임)
+
+```typescript
+/**
+ * AI 기반 타입 오류 수정
+ * @param code 현재 코드
+ * @param errors 타입 오류 목록
+ * @param interfacePath 인터페이스 경로 (컨텍스트)
+ * @returns 수정된 코드
+ */
+async function fixTypeErrors(
+  code: string,
+  errors: string[],
+  interfacePath: string
+): Promise<string> {
+  // TODO: AI 기반 수정 로직 구현
+  // - 타입 오류 분석
+  // - import 추가
+  // - 타입 이름 수정
+  // - 코드 재생성
+
+  // 현재는 기본 코드 반환 (추후 구현)
+  return code;
+}
+
+/**
+ * 훅 생성 (타입 체크 + AI 1차 수정)
+ */
+async function generateHookWithCheck(args: { interfacePath: string; outputPath?: string }) {
+  const { interfacePath, outputPath } = args;
+
+  // 1. 기본 훅 생성
+  let hookCode = await generateHookCode(interfacePath, outputPath);
+  const finalPath = outputPath || getDefaultPath(interfacePath);
+  await fs.writeFile(finalPath, hookCode);
+
+  // 2. 타입 체크 및 수정 (최대 3회 시도)
+  const maxRetries = 3;
+  let typeErrors: string[] = [];
+
+  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}건`);
+      hookCode = await fixTypeErrors(hookCode, typeErrors, interfacePath);
+      await fs.writeFile(finalPath, hookCode);
+    }
+  }
+
+  // 3. Lint 및 Prettier 실행
+  await runLintAndPrettier(finalPath);
+
+  // 4. 결과 반환
+  return {
+    success: true,
+    message: typeErrors.length > 0
+      ? `훅 파일 생성 완료 (타입 오류 ${typeErrors.length}건, AI 수정 후 실패)`
+      : '훅 파일 생성 완료 (타입 체크 통과)',
+    path: finalPath,
+    typeErrors: typeErrors.length > 0 ? typeErrors : undefined,  // 사용자에게 위임
+    aiFixed: typeErrors.length > 0,  // AI 시도 표시
+  };
+}
+```
+
+### 14.5 사용자 경험
+
+**타입 체크 통과:**
+```
+Store 파일 생성 완료 (타입 체크 통과)
+
+생성된 파일: src/stores/useMemberListStore.ts
+```
+
+**AI 수정 후 통과:**
+```
+Store 파일 생성 완료 (AI 수정 후 타입 체크 통과)
+
+생성된 파일: src/stores/useMemberListStore.ts
+```
+
+**AI 수정 후 실패 (결과만 표시, 질문 없음):**
+```
+Store 파일 생성 완료 (타입 오류 3건)
+
+생성된 파일: src/stores/useMemberListStore.ts
+
+타입 오류:
+- error TS2304: Cannot find name 'MemberRes'.
+- error TS2339: Property 'ds' does not exist on type '...'.
+- error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
+```
+
+### 14.6 전체 흐름도
+
+```
+┌─────────────────┐
+│  훅 파일 생성     │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  타입 체크 실행    │
+└────────┬────────┘
+         │
+    ┌────┴────┐
+    │  통과?   │
+    └────┬────┘
+         │
+    ┌────┴─────────┐
+    │              │
+   YES            NO
+    │              │
+    ▼              ▼
+┌────────┐   ┌──────────┐
+│ 완료    │   │ AI 자동  │
+└────────┘   │ 수정 시도 │
+             └─────┬────┘
+                   │
+                   ▼
+             ┌──────────┐
+             │ 타입 체크  │
+             └─────┬────┘
+                   │
+              ┌────┴────┐
+              │  통과?   │
+              └────┬────┘
+                   │
+              ┌────┴─────┐
+              │          │
+             YES         NO
+              │          │
+              ▼          ▼
+          ┌────────┐ ┌──────────┐
+          │ 완료    │ │ 결과 반환  │
+          └────────┘ │ (오류만) │
+                      └──────────┘
+}
+```
+
+### 14.5 사용자 경험
+
+**타입 체크 통과:**
+```
+훅 파일 생성 완료 (타입 체크 통과)
+
+생성된 파일: src/hooks/useMemberService.ts
+```
+
+**타입 오류 있음:**
+```
+훅 파일 생성 완료 (타입 오류 3건)
+
+생성된 파일: src/hooks/useMemberService.ts
+
+타입 오류:
+- error TS2304: Cannot find name 'MemberRes'.
+- error TS2339: Property 'ds' does not exist on type '...'.
+- error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
+
+수정하시겠습니까?
+```
+
+### 14.6 타입 오류 수정 예시
+
+**생성된 코드 (타입 오류):**
+```typescript
+// ❌ MemberRes를 찾을 수 없음
+const [list, setList] = useState<MemberRes[]>([]);
+```
+
+**수정된 코드:**
+```typescript
+// ✅ 올바른 타입으로 수정
+const [list, setList] = useState<Member[]>([]);
+```
+
+### 14.7 타입 체크 명령어
+
+```bash
+# 프로젝트에 type-check 스크립트가 있으면
+npm run type-check
+
+# 없으면 직접 실행
+npx tsc --noEmit src/hooks/useMemberService.ts
+```
+
+### 14.8 타입 오류 패턴별 수정 로직
+
+| 오류 패턴 | 수정 방법 |
+|----------|----------|
+| `Could not find namespace 'XXX'` | import 추가 또는 타입 경로 수정 |
+| `Property 'xxx' does not exist on type 'XXX'` | 타입 정의 수정 |
+| `Type 'XXX' is not assignable to type 'YYY'` | 타입 호환성 수정 |
+| `Module '"XXX"' has no exported member 'YYY'` | import 경로 또는 이름 수정 |
+
+---
+| 2회차 | 오류 수정 후 재생성 |
+| 3회차 | 마지막 시도 후 결과 반환 |
+
+### 14.5 타입 체크 명령어
+
+```bash
+# 특정 파일 타입 체크
+npx tsc --noEmit src/hooks/useMemberService.ts
+
+# 프로젝트 전체 타입 체크
+npx tsc --noEmit
+
+# 또는
+npm run type-check  # package.json에 설정된 경우
+```
+
+### 14.6 타입 오류 패턴별 수정 로직
+
+| 오류 패턴 | 수정 방법 |
+|----------|----------|
+| `Could not find namespace 'XXX'` | import 추가 또는 타입 경로 수정 |
+| `Property 'xxx' does not exist on type 'XXX'` | 타입 정의 수정 |
+| `Type 'XXX' is not assignable to type 'YYY'` | 타입 호환성 수정 |
+| `Module '"XXX"' has no exported member 'YYY'` | import 경로 또는 이름 수정 |
+
+---
+
+## 15. Store와 Hook 동시 생성 (결과 요약)
+
+### 15.1 사용자 시나리오
+
+사용자가 단일 요청으로 Store와 Hook을 동시에 생성할 때, 각각의 개별 결과가 아닌 **요약된 결과**를 보여줍니다.
+
+```typescript
+// 사용자 요청
+generateStoreAndHook({ interfacePath: "/path/to/MemberRepository.ts" })
+```
+
+### 15.2 결과 요약 형식
+
+**성공 시:**
+```
+✅ Store 및 Hook 생성 완료
+
+생성된 파일:
+- src/stores/useMemberListStore.ts (Store)
+- src/hooks/useMemberService.ts (Hook)
+
+Store: 타입 체크 통과
+Hook: 타입 체크 통과
+```
+
+**부분 실패 시 (Hook 타입 오류):**
+```
+⚠️ Store 및 Hook 생성 완료 (일부 타입 오류)
+
+생성된 파일:
+- src/stores/useMemberListStore.ts (Store)
+- src/hooks/useMemberService.ts (Hook)
+
+Store: 타입 체크 통과
+Hook: 타입 오류 2건
+
+Hook 타입 오류:
+- error TS2304: Cannot find name 'MemberRes'.
+- error TS2339: Property 'ds' does not exist on type '...'.
+```
+
+### 15.3 MCP 도구 설계
+
+#### 옵션 A: 통합 도구
+
+```typescript
+// 도구: generate-store-and-hook
+{
+  "name": "generate-store-and-hook",
+  "description": "Store와 Hook을 동시에 생성합니다",
+  "inputSchema": {
+    "type": "object",
+    "properties": {
+      "interfacePath": { "type": "string" },
+      "storeOutputPath": { "type": "string" },
+      "hookOutputPath": { "type": "string" },
+      "storeType": { "type": "number" }
+    }
+  }
+}
+```
+
+#### 옵션 B: 개별 도구 (현재 방식)
+
+```typescript
+// 사용자가 각각 호출
+generateStore({ interfacePath, outputPath: "stores/useMemberListStore.ts" })
+generateHook({ interfacePath, outputPath: "hooks/useMemberService.ts" })
+```
+
+### 15.4 결과 요약 로직
+
+```typescript
+/**
+ * Store와 Hook 동시 생성 (결과 요약)
+ */
+async function generateStoreAndHook(args: {
+  interfacePath: string;
+  storeOutputPath?: string;
+  hookOutputPath?: string;
+  storeType?: number;
+}) {
+  const { interfacePath, storeOutputPath, hookOutputPath, storeType = 1 } = args;
+
+  // 1. Store 생성
+  const storeResult = await generateStore({
+    interfacePath,
+    outputPath: storeOutputPath || getDefaultStorePath(interfacePath),
+    storeType,
+  });
+
+  // 2. Hook 생성
+  const hookResult = await generateHook({
+    interfacePath,
+    outputPath: hookOutputPath || getDefaultHookPath(interfacePath),
+  });
+
+  // 3. 결과 요약
+  const storeData = JSON.parse(storeResult.content[0].text);
+  const hookData = JSON.parse(hookResult.content[0].text);
+
+  // 4. 요약된 결과 반환
+  return {
+    content: [{
+      type: 'text',
+      text: formatSummary(storeData, hookData),
+    }],
+  };
+}
+
+/**
+ * 결과 요약 포맷팅
+ */
+function formatSummary(storeData: any, hookData: any): string {
+  const lines: string[] = [];
+
+  // 헤더
+  const hasErrors = storeData.typeErrors || hookData.typeErrors;
+  const icon = hasErrors ? '⚠️' : '✅';
+  const title = hasErrors ? 'Store 및 Hook 생성 완료 (일부 타입 오류)' : 'Store 및 Hook 생성 완료';
+
+  lines.push(`${icon} ${title}\n`);
+
+  // 생성된 파일
+  lines.push('생성된 파일:');
+  lines.push(`- ${storeData.outputPath} (Store)`);
+  lines.push(`- ${hookData.path} (Hook)\n`);
+
+  // Store 상태
+  const storeStatus = storeData.typeErrors
+    ? `Store: 타입 오류 ${storeData.typeErrors.length}건`
+    : 'Store: 타입 체크 통과';
+  lines.push(storeStatus);
+
+  // Hook 상태
+  const hookStatus = hookData.typeErrors
+    ? `Hook: 타입 오류 ${hookData.typeErrors.length}건`
+    : 'Hook: 타입 체크 통과';
+  lines.push(hookStatus);
+
+  // 타입 오류가 있으면 추가
+  const allErrors = [
+    ...(storeData.typeErrors || []).map((e: string) => `[Store] ${e}`),
+    ...(hookData.typeErrors || []).map((e: string) => `[Hook] ${e}`),
+  ];
+
+  if (allErrors.length > 0) {
+    lines.push('\n타입 오류:');
+    allErrors.forEach(error => lines.push(`- ${error}`));
+  }
+
+  return lines.join('\n');
+}
+```
+
+### 15.5 사용자 경험 비교
+
+| 방식 | 장점 | 단점 |
+|------|------|------|
+| **개별 결과** | 각 파일의 상세 결과 확인 | 결과가 길어짐, 전체 현황 파악 어려움 |
+| **요약 결과** | 전체 현황 한눈에 파악 | 개별 상세 정보는 별도 확인 필요 |
+
+### 15.6 구현 우선순위
+
+1. ✅ Store 생성 결과에 `typeErrors` 필드 추가
+2. ✅ Hook 생성 결과에 `typeErrors` 필드 추가
+3. ⏳ 통합 도구 `generate-store-and-hook` 구현
+4. ⏳ 결과 요약 함수 `formatSummary` 구현
+
+---
+
+## 16. 향후 확장 가능성
+
+1. **커스텀 훅 옵션**: 사용자가 네이밍 규칙, spinning 관리 방식 등을 선택 가능
+2. **타입스크립트 엄격 모드**: 더 엄격한 타입 검증
+3. **테스트 코드 자동 생성**: 훅에 대한 테스트 코드 자동 생성
+4. **문서 자동 생성**: 훅 사용법에 대한 문서 자동 생성
+
+---
+
+## 17. 참고 자료
+
+- NH-FE-B 리액트 훅 패턴 분석 결과
+- 기존 Store 생성 템플릿
+- React Hooks 공식 문서