@axboot-mcp/mcp-server 1.0.0

package/src/handlers/generate.ts

@@ -0,0 +1,911 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { spawn, execSync } from 'child_process';
+import { analyzeInterface, InterfaceAnalysis, extractIdFieldFromRequest } from './analyze.js';
+import { getTemplate, TemplateVariables } from '../templates/index.js';
+import {
+  getInitialValues,
+  getStoreTypeFields,
+  getRequiredImports,
+  getNamingRules,
+  getImplementationRules,
+  getStoreTypeInfo,
+  getCachedDocs
+} from '../docs/index.js';
+
+/**
+ * 프로젝트 루트 찾기 (tsconfig.json이 있는 위치)
+ * @param startPath 시작 경로 (생성된 파일 경로)
+ * @returns 프로젝트 루트 경로
+ */
+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 {
+      // 파일이 없으면 상위 폴드로 이동
+      const parentDir = path.dirname(currentDir);
+      if (parentDir === currentDir) {
+        break; // 더 이상 상위 폴더가 없음
+      }
+      currentDir = parentDir;
+    }
+  }
+
+  // tsconfig.json을 찾지 못하면 기본값 (현재 작업 디렉토리)
+  return process.cwd();
+}
+
+/**
+ * package.json 확인하여 type-check 스크립트 확인
+ * @param projectRoot 프로젝트 루트 경로
+ * @returns 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;
+  }
+}
+
+/**
+ * 타입 체크 실행 (프로젝트 구조 자동 분석)
+ * @param filePath 타입 체크할 파일 경로
+ * @returns 성공 여부 및 오류 목록
+ */
+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 };
+  }
+}
+
+export async function generateStore(args: {
+  interfacePath: string;
+  outputPath: string;
+  storeType?: number;
+  storeName?: string;
+}) {
+  const { interfacePath, outputPath, storeType = 1, storeName = 'useGeneratedStore' } = args;
+
+  // 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;
+
+  // 유효성 검사: 메서드가 없는 경우 스토어 생성 불가
+  if (!analysis.methods || analysis.methods.length === 0) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: '인터페이스에 메서드가 없습니다. Repository 또는 Interface 파일에 메서드를 정의해주세요.',
+          }),
+        },
+      ],
+    };
+  }
+
+  // 유효성 검사: services/index.ts에 export되지 않은 Service는 건너뜀
+  // isServiceExported가 false이면 실제로 export되지 않은 것으로 간주
+  if (analysis.isServiceExported === false) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: `services/index.ts에 export되지 않은 Repository입니다. (${analysis.className})`,
+            skip: true, // 스킵 대상임을 표시
+          }),
+        },
+      ],
+    };
+  }
+
+  // 유효성 검사: 리스트 메서드가 없는 경우 스토어 생성 불가
+  const listMethods = analysis.methods.filter((m) => m.isListMethod);
+  if (listMethods.length === 0) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: `리스트 메서드를 찾을 수 없습니다. Repository에 목록 조회 메서드가 필요합니다. (${analysis.className})`,
+          }),
+        },
+      ],
+    };
+  }
+
+  // 2. 템플릿 로드 (통합 템플릿 사용)
+  const { unifiedTemplate } = await import('../templates/index.js');
+  const template = unifiedTemplate;
+
+  // 3. 템플릿 변수 빌드
+  const variables = buildTemplateVariables(analysis, storeType, storeName);
+
+  // 4. 템플릿 적용
+  const storeCode = applyTemplate(template, variables);
+
+  // 5. 파일 생성
+  try {
+    const outputDir = path.dirname(outputPath);
+    await fs.mkdir(outputDir, { recursive: true });
+    await fs.writeFile(outputPath, storeCode, 'utf-8');
+
+    // 6. 타입 체크 (최대 3회 시도)
+    const maxRetries = 3;
+    let typeErrors: string[] = [];
+    let aiFixed = false;
+
+    for (let i = 0; i < maxRetries; i++) {
+      const result = await typeCheck(outputPath);
+
+      if (result.success) {
+        break; // 타입 체크 통과
+      }
+
+      // 오류 수집
+      typeErrors = result.errors || [];
+
+      // 마지막 시도이면 종료 (사용자에게 위임)
+      if (i === maxRetries - 1) {
+        break;
+      }
+
+      // 1차 시도: AI 자동 수정
+      if (i === 0) {
+        console.log(`[AI 자동 수정] 타입 오류 ${typeErrors.length}건`);
+        // TODO: AI 기반 자동 수정 로직 (fixTypeErrors 함수)
+        // storeCode = await fixTypeErrors(storeCode, typeErrors, interfacePath);
+        // await fs.writeFile(outputPath, storeCode, 'utf-8');
+        aiFixed = true;
+      }
+    }
+
+    // 7. Lint 및 Prettier 실행 (비동기로 실행하고 실패해도 파일 생성은 성공으로 처리)
+    runLintAndPrettier(outputPath).catch((err) => {
+      console.warn(`Lint/Prettier 실행 중 경고: ${err}`);
+    });
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: true,
+            message: typeErrors.length > 0
+              ? `Store 파일 생성 완료 (타입 오류 ${typeErrors.length}건${aiFixed ? ', AI 수정 후 실패' : ''})`
+              : 'Store 파일 생성 완료 (타입 체크 통과)',
+            outputPath,
+            analysis: {
+              className: analysis.className,
+              serviceName: analysis.serviceName,
+              methodCount: analysis.methods.length,
+              hasPage: analysis.hasPage,
+            },
+            typeErrors: typeErrors.length > 0 ? typeErrors : undefined,  // 타입 오류가 있으면 결과에 포함
+            aiFixed: aiFixed,  // AI 시도 여부 표시
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+          }),
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * 템플릿 변수 빌드
+ * docs 폴더의 패턴 정보를 활용하여 더 정확한 변수 생성
+ */
+export function buildTemplateVariables(
+  analysis: InterfaceAnalysis,
+  storeType: number,
+  storeName: string
+): TemplateVariables {
+  // docs에서 패턴 정보 로드
+  const typeFields = getStoreTypeFields(storeType);
+  const initialValues = getInitialValues(storeType);
+  const typeInfo = getStoreTypeInfo(storeType);
+  const namingRules = getNamingRules();
+  const implementationRules = getImplementationRules();
+
+  // List 메서드 찾기 - 우선순위에 따라 선택
+  // 1. 엔티티명 + List (예: postProductListPrd)
+  // 2. list + 엔티티명 (예: postListProduct)
+  // 3. 그 외 list 포함 메서드
+  const className = analysis.className || '';
+  const entityName = className.replace('Repository', ''); // Product
+
+  const listMethods = analysis.methods.filter((m) => m.isListMethod);
+
+  // 우선순위별로 메서드 찾기
+  // 1순위: 페이징이 있는 메서드 우선 (hasPage === true)
+  let selectedMethod = listMethods.find((m) =>
+    m.name.toLowerCase().includes(`list${entityName.toLowerCase()}`) && m.hasPage === true
+  );
+
+  // 2순위: 엔티티명 포함 메서드
+  if (!selectedMethod) {
+    selectedMethod = listMethods.find((m) =>
+      m.name.toLowerCase().includes(`list${entityName.toLowerCase()}`)
+    );
+  }
+
+  // 3순위: 페이징이 있는 메서드
+  if (!selectedMethod) {
+    selectedMethod = listMethods.find((m) => m.hasPage === true);
+  }
+
+  // 4순위: 가장 짧은 이름 (구체적일수록 이름이 짧음)
+  if (!selectedMethod && listMethods.length > 0) {
+    selectedMethod = listMethods.reduce((prev, curr) =>
+      curr.name.length < prev.name.length ? curr : prev
+    );
+  }
+
+  // List 메서드가 없으면 빈 기본값 사용 (첫 번째 메서드를 강제로 사용하지 않음)
+  const defaultListMethod: any = { name: '', requestType: 'any', responseType: 'any', isListMethod: false, comment: '' };
+  selectedMethod = selectedMethod || defaultListMethod;
+
+  // List 메서드 주석 추출
+  const listMethodComment = selectedMethod?.comment || '';
+
+  // 삭제/저장/상세 메서드 찾기 - 우선 순위: 주석에 "엔티티명 + 저장/삭제" → 주석에 "저장/삭제" → 메서드명 키워드
+  const deleteMethod = findMethodByPriority(analysis.methods, entityName, 'delete');
+  const saveMethod = findMethodByPriority(analysis.methods, entityName, 'save');
+  // detail 메서드는 list 메서드와 중복되지 않아야 함
+  const detailMethodCandidate = findMethodByPriority(analysis.methods, entityName, 'detail');
+  const detailMethod = detailMethodCandidate?.name !== selectedMethod?.name ? detailMethodCandidate : null;
+
+  // 삭제/저장/상세/엑셀 메서드 주석 추출
+  const deleteMethodComment = deleteMethod?.comment || '';
+  const saveMethodComment = saveMethod?.comment || '';
+  const detailMethodComment = detailMethod?.comment || '';
+
+  // Store 이름 처리 (docs 네이밍 규칙 준수)
+  const storeNameCamel = storeName; // useMemberListStore
+  const storeNamePascal = toPascalCase(storeName.replace(/^use/, '')); // MemberListStore
+  const storeInterface = `${storeNamePascal.replace(/Store$/, '')}Store`; // memberListStore
+
+  // Service 이름
+  const serviceName = analysis.serviceName || 'UnknownService';
+
+  // TypeScript 기본 타입 키워드 목록 (import에서 제외할 타입)
+  const TS_KEYWORDS = new Set([
+    'void', 'any', 'unknown', 'never', 'null', 'undefined',
+    'boolean', 'number', 'string', 'object', 'symbol', 'bigint'
+  ]);
+
+  // Request/Response 타입
+  const rawListRequest = selectedMethod!.requestType || 'any';
+  const listResponse = selectedMethod!.responseType || 'any';
+
+  // 삭제/저장 Request 타입
+  const rawDeleteRequest = deleteMethod?.requestType || 'any';
+  const rawSaveRequest = saveMethod?.requestType || 'any';
+
+  // 디버깅: deleteMethod 확인
+  if (deleteMethod) {
+    console.log('[DEBUG] deleteMethod:', { name: deleteMethod.name, requestType: deleteMethod.requestType, isRequestArray: deleteMethod.isRequestArray });
+  }
+
+  // TypeScript 키워드인 경우 빈 문자열로 처리 (extends 없이 빈 interface 사용)
+  const listRequest = TS_KEYWORDS.has(rawListRequest) ? '' : rawListRequest;
+  const deleteRequest = TS_KEYWORDS.has(rawDeleteRequest) ? '' : rawDeleteRequest;
+  const saveRequest = TS_KEYWORDS.has(rawSaveRequest) ? '' : rawSaveRequest;
+
+  // DTO 타입 추출
+  const dtoItem = analysis.dtoTypes[0] || extractDtoFromResponse(listResponse);
+
+  // 메서드 이름 (camelCase)
+  const listMethodName = toCamelCase(selectedMethod!.name);
+  const deleteMethodName = deleteMethod ? toCamelCase(deleteMethod.name) : null;
+  const saveMethodName = saveMethod ? toCamelCase(saveMethod.name) : null;
+  const detailMethodName = detailMethod ? toCamelCase(detailMethod.name) : null;
+
+  // DTO 소문자 변환
+  const dtoItemLower = toCamelCase(dtoItem);
+
+  // 페이징 여부
+  const hasPage = analysis.hasPage || false;
+
+  // API 여부 플래그 - 주석 기반 판단을 우선 적용
+  // 주석에서 "엔티티명 삭제", "엔티티명 저장" 패턴이 있으면 무조건 true
+  const hasSave = analysis.hasSaveFromComment || saveMethodName !== null;
+  const hasDelete = analysis.hasDeleteFromComment || deleteMethodName !== null;
+  const hasDetail = analysis.hasDetailFromComment || detailMethodName !== null;
+  const hasList = selectedMethod!.isListMethod;
+
+  // 파라미터 타입과 인터페이스 필드 타입 간의 호환성 판단
+  // 파라미터: id: number | string (고정)
+  // 인터페이스 필드: Repository에서 추출한 타입 (예: string | undefined)
+  const idFieldType = analysis.idFieldType || 'string | number';
+  // idFieldType이 number 또는 number|undefined인 경우 Number() 변환, string 또는 string|undefined인 경우 String() 변환
+  const isNumberOnly = idFieldType === 'number' || idFieldType === 'number | undefined';
+  const isStringOnly = idFieldType === 'string' || idFieldType === 'string | undefined';
+  const idValue = isNumberOnly ? 'Number(id)' :
+                   isStringOnly ? 'String(id)' : 'id';
+  const keyValue = isNumberOnly ? 'Number(key)' :
+                    isStringOnly ? 'String(key)' : 'key';
+
+  // Save Request 배열 여부 확인
+  const isSaveRequestArray = saveMethod?.isRequestArray || false;
+  // Delete Request 배열 여부 확인
+  const isDeleteRequestArray = deleteMethod?.isRequestArray || false;
+  // 실제 Repository Request 타입 사용 (rawDeleteRequest는 이미 line 214에서 선언됨)
+  const hasDeleteRequestType = rawDeleteRequest && rawDeleteRequest !== 'any';
+  const deleteRequestType = hasDeleteRequestType ? rawDeleteRequest : null;
+  const deleteParamType = deleteRequestType
+    ? (isDeleteRequestArray ? rawDeleteRequest + '[]' : rawDeleteRequest)
+    : (isDeleteRequestArray ? 'React.Key[]' : 'number | string');
+  const deleteParamName = deleteRequestType ? 'request' : (isDeleteRequestArray ? 'ids' : 'id');
+  const callDeleteApiDeclaration = hasDelete ? ('callDeleteApi: (' + deleteParamName + ': ' + deleteParamType + ') => Promise<void>;') : '';
+
+  // API 호출 라인 생성 (메서드가 없으면 TODO 주석)
+  // 삭제 API는 Request 인터페이스의 필수 필드를 listRequestValue에서 가져와야 함
+  const deleteApiCall = deleteMethodName
+    ? (deleteRequestType
+      ? 'await ' + serviceName + '.' + deleteMethodName + '(' + deleteParamName + ');'
+      : (isDeleteRequestArray
+        ? 'await ' + serviceName + '.' + deleteMethodName + '(' + deleteParamName + '.map(id => ({ ...get().listRequestValue, ' + (analysis.idField || 'id') + ': ' + idValue.replace(/\bid\b/g, 'id') + ' })));'
+        : 'await ' + serviceName + '.' + deleteMethodName + '({ ...get().listRequestValue, ' + (analysis.idField || 'id') + ': ' + idValue + ' });'))
+    : '// TODO: 삭제 API 호출 구현 필요\n      // await ' + serviceName + '.remove' + dtoItem + '({ id });';
+
+  const saveApiCall = saveMethodName
+    ? `${hasPage ? `request.__status__ = get().listSelectedRowKey ? ("U" as const) : ("C" as const);` : ``}
+      await ${serviceName}.${saveMethodName}(request);`
+    : `// TODO: 저장 API 호출 구현 필요\n      // await ${serviceName}.save${dtoItem}(request);`;
+
+  // === dateRange 패턴 관련 ===
+  const hasDateRange = analysis.hasDateRange || false;
+  // dateRange가 있으면 dayjs import가 항상 필요함 (기본값에 dayjs() 사용)
+  const hasDayJs = hasDateRange || (analysis.hasDayJs || false);
+  const dateRangeFields = analysis.dateRangeFields;
+  const isBgnDtm = dateRangeFields?.searchType === 'bgnDtm';
+
+  // === docs 기반 추가 변수 ===
+
+  // MetaData 필드 (docs에서 가져온 순서대로)
+  const metadataRequired = typeFields.metadata.required || [];
+  const metadataOptional = typeFields.metadata.optional || [];
+  const allMetadataFields = [...metadataRequired, ...metadataOptional];
+
+  // States 필드
+  const statesRequired = typeFields.states.required || [];
+  const statesOptional = typeFields.states.optional || [];
+
+  // Actions
+  const actionsRequired = typeFields.actions.required || [];
+  const actionsOptional = typeFields.actions.optional || [];
+
+  // Subscribe selector
+  const subscribeSelector = typeFields.subscribeSelector || [];
+
+  // 초기값 생성 (docs의 initialValues 활용)
+  const createStateFields = generateCreateStateFields(initialValues, allMetadataFields, statesOptional);
+
+  // 구현 규칙 기반 callListApi 템플릿
+  const callListApiTemplate = implementationRules.callListApi?.template || '';
+
+  // 생성될 Store에 대한 문서 참조 주석
+  const docsReference = generateDocsReference(storeType, typeInfo);
+
+  // Request 필수 필드 기본값 생성 (requiredFields에서)
+  const requiredFields = analysis.requiredFields || [];
+  const requiredFieldsDefaults = generateRequiredFieldsDefaults(requiredFields);
+
+  // Imports - 실제로 사용하는 타입만 포함 (eslint no-unused-vars 방지)
+  // Response 타입은 템플릿에서 직접 사용하지 않으므로 import 제외
+  const requiredImports = new Set<string>();
+  requiredImports.add(serviceName); // Service 항상 추가
+  // ListRequest 타입 - TypeScript 키워드가 아니면 import
+  if (listRequest && !TS_KEYWORDS.has(rawListRequest)) {
+    requiredImports.add(listRequest);
+  }
+  // ListResponse는 API 호출 반환값으로 추론되므로 import 불필요
+  if (dtoItem && dtoItem !== 'Record<string, any>' && dtoItem !== listRequest && !TS_KEYWORDS.has(dtoItem)) {
+    requiredImports.add(dtoItem); // DTO 타입 (중복 제외)
+  }
+  // Delete/Save Request 타입 - 해당 API가 존재할 때만 import (TypeScript 키워드 제외)
+  if (hasDelete && deleteRequest && !TS_KEYWORDS.has(rawDeleteRequest) && deleteRequest !== listRequest && deleteRequest !== dtoItem) {
+    requiredImports.add(deleteRequest);
+  }
+  if (hasSave && saveRequest && !TS_KEYWORDS.has(rawSaveRequest) && saveRequest !== listRequest && saveRequest !== dtoItem) {
+    requiredImports.add(saveRequest);
+  }
+
+  // 정렬
+  const allImports = Array.from(requiredImports).sort();
+
+  // prettier 규칙: import가 길 경우 멀티 라인으로
+  // prettier는 import 문에 대해 더 관대하므로 매우 긴 경우에만 멀티 라인
+  let importsLine: string;
+  if (allImports.length > 0) {
+    const importsStr = allImports.join(', ');
+    // 전체 import 문 길이 (대략): importsStr + 30 characters
+    // prettier는 import가 120자 이상일 때만 멀티 라인 선호
+    const fullLength = importsStr.length + 30;
+    if (fullLength > 120) {
+      importsLine = `import {\n  ${allImports.join(',\n  ')},\n} from "services";`;
+    } else {
+      importsLine = `import { ${importsStr} } from "services";`;
+    }
+  } else {
+    importsLine = `import { ${serviceName} } from "services";`;
+  }
+
+  return {
+    // Store 이름
+    STORE_NAME: storeNameCamel,
+    STORE_NAME_PASCAL: storeNamePascal,
+    STORE_INTERFACE: storeInterface,
+
+    // Service
+    SERVICE_NAME: serviceName,
+    LIST_METHOD_NAME: listMethodName,
+    DELETE_METHOD_NAME: deleteMethodName,
+    SAVE_METHOD_NAME: saveMethodName,
+    DETAIL_METHOD_NAME: detailMethodName,
+    DELETE_API_CALL: deleteApiCall,
+    SAVE_API_CALL: saveApiCall,
+
+    // Request/Response
+    LIST_REQUEST: listRequest,
+    LIST_REQUEST_EXTENDS: listRequest ? `extends ${listRequest}` : '', // extends 또는 빈 문자열
+    LIST_RESPONSE: listResponse,
+    ACTIONS_EXTENDS: hasPage ? 'extends PageStoreActions<States> ' : 'extends Record<string, any> ', // Actions interface extends
+    DELETE_REQUEST: deleteRequest,
+    DELETE_REQUEST_EXTENDS: deleteRequest ? `extends ${deleteRequest}` : '',
+    SAVE_REQUEST: saveRequest,
+    SAVE_REQUEST_EXTENDS: saveRequest ? `extends ${saveRequest}` : '',
+    SAVE_PARAM_TYPE: saveRequest ? (isSaveRequestArray ? saveRequest + '[]' : saveRequest) : dtoItem, // Save 메서드 파라미터 타입 (SaveRequest 있으면 그것 사용, 없으면 DTO, 배열이면 [] 추가)
+    DTO_ITEM: dtoItem,
+    DTO_ITEM_LOWER: dtoItemLower,
+
+    // 페이징 여부
+    HAS_PAGE: hasPage,
+    HAS_SAVE: hasSave,
+    HAS_DELETE: hasDelete,
+    HAS_DETAIL: hasDetail,
+    HAS_LIST: hasList,
+    HAS_REORDER: storeType === 6, // Type 6 (재정렬 가능 리스트)만 재정렬 기능 활성화
+    HAS_LIST_REQUEST_PARAMS: !!listRequest, // ListRequest가 빈 문자열이 아니면 true (void가 아닌 경우)
+    HAS_LIST_RESPONSE: Boolean(listResponse && listResponse !== 'void' && listResponse !== 'any'), // 응답 타입이 void가 아니면 true (response.ds 접근용)
+    HAS_PAGE_IN_REQUEST: analysis.hasPageInRequest || false, // Request에 pageNumber/pageSize 필드가 있는지 (listRequestValue 초기값 결정용)
+    HAS_EXCEL: (analysis.hasExcel || false) && !!analysis.excelMethodName, // 엑셀 메서드가 있을 때만 true
+    EXCEL_METHOD_NAME: analysis.excelMethodName,
+    EXCEL_PARAM_TYPE: listRequest || 'ListRequest', // 엑셀 메서드 파라미터 타입 (ListRequest 또는 기본값)
+    IS_EXCEL_REQUEST_ARRAY: analysis.isExcelRequestArray || false, // 엑셀 Request 배열 여부
+    IS_DELETE_REQUEST_ARRAY: isDeleteRequestArray, // 삭제 Request 배열 여부
+    HAS_ARRAY_DELETE_API: analysis.hasArrayDeleteApi || false, // 다른 삭제 메서드 중 배열이 있는지 (callMultiDeleteApi 생성용)
+
+    // dateRange/dayjs 패턴
+    HAS_DATE_RANGE: hasDateRange,
+    HAS_DAY_JS: hasDayJs,
+    IS_BGNDTM: isBgnDtm,
+
+    // __status__ 패턴용 ID 필드
+    // idFieldType이 정확히 'number'인 경우 Number() 변환, 'string | number'인 경우 그대로 사용, string인 경우 String() 변환
+    ID_FIELD: analysis.idField || 'id',
+    CALL_DELETE_API_DECLARATION: callDeleteApiDeclaration, // callDeleteApi Actions interface 선언
+    DELETE_PARAM_NAME: deleteParamName,
+    DELETE_PARAM_TYPE: deleteParamType,
+    ID_FIELD_TYPE: analysis.idFieldType || 'string | number',
+    ID_FIELD_NEEDS_STRING_CONVERSION: !(analysis.idFieldType || 'string | number').includes('number'),
+    ID_FIELD_VALUE: idValue,
+    ID_FIELD_KEY_VALUE: keyValue,
+
+    // Request 필수 필드 기본값
+    REQUIRED_FIELDS_DEFAULTS: requiredFieldsDefaults,
+
+    // Imports
+    IMPORTS: importsLine,
+    LIST_METHOD_COMMENT: listMethodComment,
+    DELETE_METHOD_COMMENT: deleteMethodComment,
+    SAVE_METHOD_COMMENT: saveMethodComment,
+    DETAIL_METHOD_COMMENT: detailMethodComment,
+
+    // 응답 필드 정보
+    LIST_RESPONSE_FIELD: selectedMethod?.responseListField || 'ds',
+    DETAIL_RESPONSE_FIELD: detailMethod?.responseDetailField || 'rs',
+    IS_DIRECT_RESPONSE: detailMethod?.responseDetailField === null && detailMethod?.responseType !== undefined,
+
+    // 요청 필드 정보 (SearchParams 생성용)
+    REQUEST_FIELDS: analysis.requestFields ? JSON.stringify(analysis.requestFields) : '[]',
+
+    // === docs 기반 추가 변수 ===
+    METADATA_FIELDS: allMetadataFields.join(', '),
+    METADATA_REQUIRED: metadataRequired.join(', '),
+    METADATA_OPTIONAL: metadataOptional.join(', '),
+    STATES_REQUIRED: statesRequired.join(', '),
+    STATES_OPTIONAL: statesOptional.join(', '),
+    ACTIONS_REQUIRED: actionsRequired.join(', '),
+    ACTIONS_OPTIONAL: actionsOptional.join(', '),
+    SUBSCRIBE_SELECTOR: subscribeSelector.join(', '),
+    CREATE_STATE_FIELDS: createStateFields,
+    CALL_LIST_API_TEMPLATE: callListApiTemplate,
+    DOCS_REFERENCE: docsReference,
+    STORE_TYPE_NAME: typeInfo?.name || `Type ${storeType}`,
+    STORE_TYPE_DESCRIPTION: typeInfo?.description || '',
+  };
+}
+
+/**
+ * Response 타입에서 DTO 추출
+ */
+function extractDtoFromResponse(responseType: string): string {
+  // PostMemberListMemberResponse -> MemberRes
+  const match = responseType.match(/Post\w+?(\w+)Response/);
+  if (match) {
+    const base = match[1];
+    // Member -> MemberRes, ListMember -> MemberRes
+    if (base.startsWith('List')) {
+      return base.replace('List', '') + 'Res';
+    }
+    return base + 'Res';
+  }
+  return 'unknown';
+}
+
+/**
+ * createState 필드 생성 (docs initialValues 활용)
+ */
+function generateCreateStateFields(
+  initialValues: any,
+  metadataFields: string[],
+  statesOptional: string[]
+): string {
+  const lines: string[] = [];
+
+  // MetaData 필드 초기값
+  for (const field of metadataFields) {
+    if (initialValues[field] !== undefined) {
+      lines.push(`  ${field}: ${JSON.stringify(initialValues[field])},`);
+    } else if (field === 'programFn') {
+      lines.push(`  programFn: undefined,`);
+    } else if (field.includes('Value') || field.includes('Widths') || field.includes('Params') || field.includes('Keys')) {
+      lines.push(`  ${field}: [],`);
+    } else if (field === 'flexGrow') {
+      lines.push(`  flexGrow: 400,`);
+    } else if (field === 'formActive') {
+      lines.push(`  formActive: false,`);
+    }
+  }
+
+  // States 필드 초기값
+  const defaultStates: Record<string, string> = {
+    routePath: 'undefined',
+    listSpinning: 'false',
+    listData: '[]',
+    listPage: '{ currentPage: 0, totalPages: 0 }',
+    selectedItem: 'undefined',
+    detail: 'undefined',
+    saveRequestValue: '{}',
+    detailLoading: 'false',
+    checkedRowKeys: '[]',
+    listSelectedRowKey: '""',
+    modalOpen: 'false',
+  };
+
+  for (const [field, defaultValue] of Object.entries(defaultStates)) {
+    if (!metadataFields.includes(field)) {
+      lines.push(`  ${field}: ${defaultValue},`);
+    }
+  }
+
+  // 추가 States 옵션 필드
+  for (const field of statesOptional) {
+    if (!metadataFields.includes(field) && !defaultStates[field]) {
+      if (field.includes('Spinning') || field.includes('Loading') || field === 'isDirty') {
+        lines.push(`  ${field}: false,`);
+      } else {
+        lines.push(`  ${field}: undefined,`);
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * 문서 참조 주석 생성
+ */
+function generateDocsReference(storeType: number, typeInfo: any): string {
+  const typeName = typeInfo?.name || `Type ${storeType}`;
+  const description = typeInfo?.description || '';
+  const examples = typeInfo?.examples || [];
+
+  const lines: string[] = [];
+  lines.push(`/**`);
+  lines.push(` * Store Pattern: ${typeName}`);
+  if (description) {
+    lines.push(` * ${description}`);
+  }
+  if (examples.length > 0) {
+    lines.push(` *`);
+    lines.push(` * Examples:`);
+    for (const example of examples) {
+      lines.push(` * - ${example}`);
+    }
+  }
+  lines.push(` *`);
+  lines.push(` * Generated based on NH-FE-B Store patterns`);
+  lines.push(` * See: src/docs/store-patterns-usage-guide.md`);
+  lines.push(` */`);
+
+  return lines.join('\n');
+}
+
+/**
+ * 템플릿 적용 - Mustache.js 사용
+ */
+function applyTemplate(template: string, variables: TemplateVariables): string {
+  const Mustache = require('mustache');
+
+  // TypeScript 코드 생성이므로 HTML 이스케이프 비활성화
+  // 기본 escape 함수를 덮어써서 원본 그대로 반환
+  const originalEscape = Mustache.escape;
+  Mustache.escape = (text: any) => String(text);
+
+  try {
+    // Mustache.js를 사용하여 템플릿 렌더링
+    // {{#KEY}}...{{/KEY}}: 조건부 블록 (truthy일 때 내용 포함)
+    // {{^KEY}}...{{/KEY}}: 역조건부 블록 (falsy일 때 내용 포함)
+    // {{KEY}}: 변수 치환
+    let result = Mustache.render(template, variables);
+
+    // 후처리: 빈 줄 제거만 수행 (정규식 제거로 인한 함수 시그니처 손실 방지)
+    result = result
+      // 빈 줄 제거 (연속된 2개 이상의 줄바꿈을 하나로 줄임)
+      .replace(/\n\s*\n\s*\n/g, '\n\n')
+      // 빈 줄 정리
+      .replace(/\n\s*\n/g, '\n');
+
+    return result;
+  } finally {
+    // 원래 escape 함수 복원
+    Mustache.escape = originalEscape;
+  }
+}
+
+/**
+ * PascalCase 변환
+ */
+function toPascalCase(str: string): string {
+  return str.replace(/(^|-)(\w)/g, (_, __, char) => char.toUpperCase());
+}
+
+/**
+ * camelCase 변환
+ */
+function toCamelCase(str: string): string {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
+/**
+ * Request 필수 필드 기본값 생성
+ * 필드 이름을 기반으로 적절한 기본값 추론
+ */
+function generateRequiredFieldsDefaults(requiredFields: string[]): string {
+  const lines: string[] = [];
+
+  for (const field of requiredFields) {
+    // 필드 이름을 분석하여 기본값 결정
+    const lowerField = field.toLowerCase();
+
+    // Tpcd, tpCd, code, cd 등으로 끝나면 빈 문자열
+    if (/(Tpcd|tpCd|Code|cd|Type|type)$/.test(field)) {
+      lines.push(`    ${field}: '',`);
+    }
+    // Yn으로 끝나면 빈 문자열
+    else if (/(Yn|yn)$/.test(field)) {
+      lines.push(`    ${field}: '',`);
+    }
+    // No, Number로 끝나면 빈 문자열 또는 0
+    else if (/(No|Number)$/.test(field)) {
+      lines.push(`    ${field}: '',`);
+    }
+    // Date, Dt, Dtm으로 끝나면 빈 문자열
+    else if (/(Date|Dt|Dtm)$/.test(field)) {
+      lines.push(`    ${field}: '',`);
+    }
+    // 그 외에는 빈 문자열
+    else {
+      lines.push(`    ${field}: '',`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * 메서드를 우선 순위별로 찾기
+ * 1순위: 주석에 "첫단어 + 공백 + 저장/삭제/상세" 정확 매칭 (예: "배너 저장")
+ *        "배너 순서저장 저장"은 첫단어+공백+키워드 패턴이 아니므로 제외
+ * 2순위: 주석에 "저장/삭제/상세"만 있는 경우
+ * 3순위: 메서드명에 키워드 포함
+ */
+function findMethodByPriority(
+  methods: any[],
+  entityName: string,
+  actionType: 'delete' | 'save' | 'detail'
+): any | undefined {
+  const keywords = {
+    delete: ['delete', 'remove'],
+    save: ['save', 'insert', 'create'],
+    detail: ['detail', 'info', 'get'],
+  };
+  const koreanKeywords = {
+    delete: '삭제',
+    save: '저장',
+    detail: '상세',
+  };
+
+  const actionKeywords = keywords[actionType];
+  const koreanKeyword = koreanKeywords[actionType];
+
+  // 1순위: 주석에서 "첫단어 + 공백 + 한글 키워드" 정확 매칭
+  // 주석: "/* 배너 저장 */" → 첫단어 "배너" + 공백 + "저장" → 매칭!
+  // 주석: "/* 배너 순서저장 저장 */" → 첫단어 "배너" + 공백 + "순서저장" → 매칭 실패
+  // detail의 경우: "/* 상세 조회 */", "/* 정보 조회 */", "/* 내역 조회 */"도 매칭
+  for (const m of methods) {
+    if (m.comment) {
+      // 주석 정제: /*, */, 앞뒤 공백 제거
+      const cleaned = m.comment.replace(/\/\*\*?|\*\//g, '').trim();
+      // 주의: \b (word boundary)는 한글에서 제대로 작동하지 않으므로 사용하지 않음
+      // 대신 공백으로 분리하여 두 번째 단어가 정확히 키워드인지 확인
+      const parts = cleaned.split(/\s+/);
+      if (parts.length >= 2) {
+        // 일반 패턴: 첫단어 + 공백 + 키워드 (예: "배너 저장")
+        if (parts[1] === koreanKeyword) {
+          return m;
+        }
+        // detail 추가 패턴: "상세 조회", "정보 조회", "내역 조회"
+        if (actionType === 'detail' && parts[1] === '조회' && ['상세', '정보', '내역'].includes(parts[0])) {
+          return m;
+        }
+      }
+    }
+  }
+
+  // 2순위: 주석에 한글 키워드만 있는 경우
+  // detail의 경우 "조회" 키워드도 포함
+  const koreanMatch = methods.find((m) => {
+    if (!m.comment) return false;
+    const hasKeyword = m.comment.includes(koreanKeyword);
+    const hasInquiry = actionType === 'detail' && m.comment.includes('조회');
+    return hasKeyword || hasInquiry;
+  });
+  if (koreanMatch) return koreanMatch;
+
+  // 3순위: 메서드명에 키워드 포함
+  const nameMatch = methods.find((m) =>
+    actionKeywords.some((keyword) => m.name.toLowerCase().includes(keyword))
+  );
+  return nameMatch;
+}
+
+/**
+ * Lint 및 Prettier 실행 (프로젝트 루트 기준)
+ */
+async function runLintAndPrettier(filePath: string): Promise<void> {
+  // 프로젝트 루트 찾기
+  const projectRoot = await findProjectRoot(filePath);
+  const relativePath = path.relative(projectRoot, filePath);
+
+  // Prettier 실행
+  await runCommand('npx', ['prettier', '--write', relativePath], projectRoot);
+
+  // ESLint 실행
+  await runCommand('npx', ['eslint', '--fix', relativePath], projectRoot);
+}
+
+/**
+ * 명령 실행 헬퍼
+ */
+function runCommand(command: string, args: string[], cwd: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      cwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      shell: true,
+    });
+
+    let stderr = '';
+
+    proc.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`${command} ${args.join(' ')} failed with code ${code}: ${stderr}`));
+      }
+    });
+
+    proc.on('error', (err) => {
+      reject(err);
+    });
+  });
+}