@axboot-mcp/mcp-server 1.0.0

package/src/handlers/generate-interactive.ts

@@ -0,0 +1,840 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+import { analyzeInterface, InterfaceAnalysis } from './analyze.js';
+import { generateStore } from './generate.js';
+import { generateHook } from './generate-hook.js';
+
+/**
+ * Repository 접미사 키워드 (입력값에서 Entity명 추출용)
+ */
+const REPOSITORY_PATTERNS = [
+  /([A-Z][a-zA-Z]+)Repository/, // MemberRepository → Member
+  /([a-z][a-zA-Z]*)(?:Repository|Repo)/, // memberRepository → member
+  /(\w+?)리포/, // 회원리포 → 회원
+  /(\w+?)저장소/, // 회원저장소 → 회원
+];
+
+/**
+ * 입력값에서 검색 패턴 생성
+ * 항상 *Repository.ts 패턴으로 검색한 후, 입력값에 맞는 구체적 패턴 추가
+ */
+export function buildSearchPatternsFromInput(input: string): string[] {
+  const patterns: string[] = [];
+
+  // 1. 기본 패턴: 모든 Repository 파일 검색
+  patterns.push('**/*Repository.ts');
+
+  // 2. 입력값에서 가능한 키워드 추출 (영문, 한글 모두 지원)
+  const keywords = extractKeywordsFromInput(input);
+
+  // 3. 키워드를 포함하는 Repository 파일 검색
+  for (const keyword of keywords) {
+    // PascalCase (예: Coupon)
+    const pascalCase = keyword.charAt(0).toUpperCase() + keyword.slice(1).toLowerCase();
+    patterns.push(`**/*${pascalCase}*Repository.ts`);
+
+    // camelCase (예: coupon)
+    const camelCase = keyword.toLowerCase();
+    patterns.push(`**/*${camelCase}*Repository.ts`);
+
+    // 대문자만 (예: COUPON)
+    const upperCase = keyword.toUpperCase();
+    patterns.push(`**/*${upperCase}*Repository.ts`);
+  }
+
+  // 중복 제거
+  return [...new Set(patterns)];
+}
+
+/**
+ * 입력값에서 키워드 추출 (영문, 한글, 특수문자 처리)
+ */
+function extractKeywordsFromInput(input: string): string[] {
+  const keywords: string[] = [];
+
+  // 1. Repository 접미사 제거
+  const withoutRepo = input.replace(/Repository|리포|저장소/gi, '');
+
+  // 2. 영문 키워드 추출
+  const englishMatches = withoutRepo.match(/[a-zA-Z]+/g);
+  if (englishMatches) {
+    keywords.push(...englishMatches);
+  }
+
+  // 3. 한글 키워드 추출
+  const koreanMatches = withoutRepo.match(/[가-힣]+/g);
+  if (koreanMatches) {
+    keywords.push(...koreanMatches);
+  }
+
+  // 4. 입력값 전체도 추가 (예: "쿠폰")
+  if (withoutRepo.trim().length > 0) {
+    keywords.push(withoutRepo.trim());
+  }
+
+  return [...new Set(keywords)];
+}
+
+/**
+ * 입력값에서 가능한 Repository 이름들 추출 (AI 추론 보조용)
+ */
+export function extractPossibleRepositoryNames(input: string): {
+  originalInput: string;
+  possibleNames: string[];
+  searchPatterns: string[];
+  keywords: string[];
+} {
+  const patterns = buildSearchPatternsFromInput(input);
+  const keywords = extractKeywordsFromInput(input);
+
+  // 패턴에서 가능한 Entity명 추출
+  const entityNames: string[] = [];
+
+  for (const pattern of patterns) {
+    // **/MemberRepository.ts → Member
+    const match = pattern.match(/\/\*?\*?\/?([A-Z][a-zA-Z]+)Repository/);
+    if (match) {
+      entityNames.push(match[1]);
+    }
+    // **/*member*.ts → member
+    const wildcardMatch = pattern.match(/\*?\/?\*([a-zA-Z]+)\*/);
+    if (wildcardMatch) {
+      entityNames.push(wildcardMatch[1]);
+    }
+  }
+
+  return {
+    originalInput: input,
+    possibleNames: [...new Set(entityNames)],
+    searchPatterns: patterns,
+    keywords: [...new Set(keywords)]
+  };
+}
+
+/**
+ * 사용자 선택 타입
+ */
+export interface UserSelections {
+  /** 선택한 파일 인덱스 (1부터 시작) */
+  fileIndex?: number;
+  /** Store 경로 (null이면 제안 경로 사용) */
+  storePath?: string | null;
+  /** Hook 경로 (null이면 제안 경로 사용) */
+  hookPath?: string | null;
+  /** 경로 확인 완료 플래그 (true면 생성 진행) */
+  confirmed?: boolean;
+}
+
+/**
+ * 대화형 응답
+ */
+export interface InteractiveResponse {
+  success: boolean;
+  status: 'complete' | 'need_file_selection' | 'need_path_confirmation' | 'error';
+
+  // 오류 시
+  error?: string;
+
+  // 자연어 분석 정보
+  naturalLanguageInfo?: {
+    originalInput: string;
+    detectedKeywords: string[];
+    matchedCandidates: string[];
+  };
+
+  // 파일 선택 필요 시
+  fileCandidates?: FileCandidate[];
+
+  // 경로 확인 필요 시
+  pathSuggestions?: PathSuggestions;
+  selectedFileInfo?: SelectedFileInfo;
+
+  // 완료 시
+  result?: GenerationResult;
+}
+
+export interface FileCandidate {
+  index: number;
+  path: string;
+  relativePath: string;
+  summary: string;
+  methodCount: number;
+  entityName: string;
+  commentMatch?: {
+    hasMatch: boolean;
+    matchedText?: string;
+    matchReason?: string;
+  };
+}
+
+export interface PathSuggestions {
+  storePath: string;
+  hookPath: string;
+  repositoryPath: string;
+}
+
+export interface SelectedFileInfo {
+  fileName: string;
+  entityName: string;
+  methodCount: number;
+}
+
+export interface GenerationResult {
+  storePath: string;
+  hookPath: string;
+  storeStatus: string;
+  hookStatus: string;
+  storeErrors?: string[];
+  hookErrors?: string[];
+}
+
+/**
+ * 대화형 Store와 Hook 생성
+ *
+ * 단계:
+ * 1. 입력값 분석 → 검색 패턴 생성 (AI 추론 지원)
+ * 2. 파일 검색 → 파일 후보 목록 반환
+ * 3. 파일 선택 → 경로 제안 반환
+ * 4. 경로 확인 → 생성 완료
+ *
+ * AI가 입력값을 해석하고 적절한 Repository 이름을 추론하여
+ * fileName으로 전달하면, MCP는 다양한 패턴으로 검색을 시도합니다.
+ */
+export async function generateStoreAndHookInteractive(args: {
+  /** 파일명 또는 자연어 (예: MemberRepository, member, 회원) */
+  fileName: string;
+  /** 사용자 선택 (선택사항) */
+  userSelections?: UserSelections;
+  /** 프로젝트 루트 경로 (선택사항, 기본: 현재 작업 디렉토리) */
+  projectRoot?: string;
+}): Promise<{ content: Array<{ type: string; text: string }> }> {
+  const { fileName, userSelections, projectRoot = process.cwd() } = args;
+
+  try {
+    // 1단계: 입력값 분석 및 검색 패턴 생성
+    const extracted = extractPossibleRepositoryNames(fileName);
+
+    console.log(`[입력 분석] "${extracted.originalInput}"`);
+    console.log(`[검색 패턴] ${extracted.searchPatterns.slice(0, 3).join(', ')}${extracted.searchPatterns.length > 3 ? '...' : ''}`);
+
+    // 2단계: 파일 검색
+    const searchResult = await findRepositoryFiles(extracted.searchPatterns, projectRoot, extracted);
+
+    if (searchResult.status === 'not_found') {
+      return createResponse({
+        success: false,
+        status: 'error',
+        error: `"${fileName}"에 해당하는 Repository 파일을 찾을 수 없습니다.
+
+${searchResult.suggestions || '파일명을 확인하거나 전체 경로를 입력해주세요.'}`,
+        naturalLanguageInfo: {
+          originalInput: extracted.originalInput,
+          detectedKeywords: [],
+          matchedCandidates: extracted.possibleNames
+        }
+      });
+    }
+
+    // 여러 파일 발견된 경우 (단일 파일도 포함 - 항상 사용자 확인 필요)
+    if (searchResult.status === 'multiple_candidates' || searchResult.status === 'found') {
+      const candidates = searchResult.status === 'found'
+        ? await analyzeCandidates([searchResult.path!], extracted.keywords || [])
+        : searchResult.candidates!;
+
+      // 사용자가 아직 선택하지 않음
+      if (!userSelections?.fileIndex) {
+        return createResponse({
+          success: true,
+          status: 'need_file_selection',
+          naturalLanguageInfo: {
+            originalInput: extracted.originalInput,
+            detectedKeywords: [],
+            matchedCandidates: extracted.possibleNames
+          },
+          fileCandidates: candidates.map((c, i) => ({
+            index: i + 1,
+            path: c.path,
+            relativePath: path.relative(projectRoot, c.path),
+            summary: formatFileSummary(c),
+            methodCount: c.methodCount || 0,
+            entityName: c.entityName || 'Unknown'
+          }))
+        });
+      }
+
+      // 사용자 선택 확인
+      const selected = candidates[userSelections.fileIndex - 1];
+      if (!selected) {
+        return createResponse({
+          success: false,
+          status: 'error',
+          error: `잘못된 선택입니다. 1부터 ${candidates.length} 사이의 번호를 입력해주세요.`
+        });
+      }
+
+      return handleSingleFile(selected.path, projectRoot, userSelections);
+    }
+
+    return createResponse({
+      success: false,
+      status: 'error',
+      error: '알 수 없는 오류가 발생했습니다.'
+    });
+
+  } catch (error) {
+    return createResponse({
+      success: false,
+      status: 'error',
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+
+/**
+ * 단일 파일 처리
+ */
+async function handleSingleFile(
+  filePath: string,
+  projectRoot: string,
+  userSelections?: UserSelections,
+  extracted?: { originalInput: string; possibleNames: string[]; searchPatterns: string[] }
+): Promise<{ content: Array<{ type: string; text: string }> }> {
+
+  // 1. 인터페이스 분석
+  const analyzeResult = await analyzeInterface({ interfacePath: filePath });
+  const analyzeData = JSON.parse(analyzeResult.content[0].text);
+
+  if (!analyzeData.success) {
+    return createResponse({
+      success: false,
+      status: 'error',
+      error: `인터페이스 분석 실패: ${analyzeData.error || '알 수 없는 오류'}`
+    });
+  }
+
+  const analysis: InterfaceAnalysis = analyzeData;
+  const entityName = analysis.entityName || analysis.className?.replace('Repository', '') || 'Generated';
+  const repositoryPath = path.relative(projectRoot, filePath);
+
+  // 2. 경로 제안 (프로젝트 스캔 기반)
+  const suggestions = await suggestPaths(filePath, projectRoot, entityName);
+
+  // 사용자가 명시적으로 경로를 지정했거나 확인했는지 확인
+  const hasExplicitPaths = userSelections?.storePath !== undefined || userSelections?.hookPath !== undefined;
+  const isConfirmed = userSelections?.confirmed === true;
+
+  // 경로 제안이 필요한 경우: confirmed도 false고 명시적 경로도 없는 경우에만 제안 표시
+  // 사용자가 storePath/hookPath를 지정하면 confirmed가 없어도 즉시 생성
+  if (!isConfirmed && !hasExplicitPaths) {
+    return createResponse({
+      success: true,
+      status: 'need_path_confirmation',
+      pathSuggestions: suggestions,
+      selectedFileInfo: {
+        fileName: path.basename(filePath),
+        entityName,
+        methodCount: analysis.methods?.length || 0
+      },
+      naturalLanguageInfo: extracted ? {
+        originalInput: extracted.originalInput,
+        detectedKeywords: [],
+        matchedCandidates: extracted.possibleNames
+      } : undefined
+    });
+  }
+
+  // 3. 경로 결정
+  const finalStorePath = userSelections.storePath === null
+    ? suggestions.storePath
+    : (userSelections.storePath || suggestions.storePath);
+
+  const finalHookPath = userSelections.hookPath === null
+    ? suggestions.hookPath
+    : (userSelections.hookPath || suggestions.hookPath);
+
+  // 4. Store 생성
+  const storeResult = await generateStore({
+    interfacePath: filePath,
+    outputPath: finalStorePath,
+    storeType: 1,
+    storeName: `use${entityName}ListStore`
+  });
+
+  const storeData = JSON.parse(storeResult.content[0].text);
+
+  // 5. Hook 생성
+  const hookResult = await generateHook({
+    interfacePath: filePath,
+    outputPath: finalHookPath
+  });
+
+  const hookData = JSON.parse(hookResult.content[0].text);
+
+  // 6. 결과
+  if (!storeData.success || !hookData.success) {
+    return createResponse({
+      success: false,
+      status: 'error',
+      error: `Store 또는 Hook 생성 실패:\n${storeData.error || ''}\n${hookData.error || ''}`
+    });
+  }
+
+  return createResponse({
+    success: true,
+    status: 'complete',
+    result: {
+      storePath: finalStorePath,
+      hookPath: finalHookPath,
+      storeStatus: storeData.typeErrors
+        ? `Store: 타입 오류 ${storeData.typeErrors.length}건`
+        : 'Store: 타입 체크 통과',
+      hookStatus: hookData.typeErrors
+        ? `Hook: 타입 오류 ${hookData.typeErrors.length}건`
+        : 'Hook: 타입 체크 통과',
+      storeErrors: storeData.typeErrors,
+      hookErrors: hookData.typeErrors
+    }
+  });
+}
+
+/**
+ * Repository 파일 검색
+ */
+async function findRepositoryFiles(
+  searchPatterns: string[],
+  projectRoot: string,
+  extracted?: { originalInput: string; possibleNames: string[]; searchPatterns: string[]; keywords: string[] }
+) {
+  const allFiles: string[] = [];
+
+  for (const pattern of searchPatterns) {
+    const files = await glob(pattern, {
+      cwd: projectRoot,
+      absolute: true,
+      ignore: ['**/node_modules/**', '**/dist/**', '**/build/**']
+    });
+    allFiles.push(...files);
+  }
+
+  // 중복 제거
+  const uniqueFiles = [...new Set(allFiles)];
+
+  if (uniqueFiles.length === 0) {
+    // 분석 결과가 있으면 도움말 제공
+    let suggestions = '';
+    if (extracted && extracted.possibleNames.length > 0) {
+      suggestions = `입력값: "${extracted.originalInput}"\n`;
+      suggestions += `가능한 Repository: ${extracted.possibleNames.join(', ')}\n`;
+      if (extracted.keywords && extracted.keywords.length > 0) {
+        suggestions += `검색 키워드: ${extracted.keywords.join(', ')}\n`;
+      }
+      suggestions += `\n검색한 패턴 (처음 3개):\n`;
+      suggestions += extracted.searchPatterns.slice(0, 3).map(p => `- ${p}`).join('\n');
+      suggestions += `\n\n파일을 찾을 수 없습니다. 파일명을 확인하거나 전체 경로를 입력해주세요.`;
+    } else {
+      suggestions = `검색 패턴:\n`;
+      suggestions += searchPatterns.slice(0, 5).map(p => `- ${p}`).join('\n');
+      suggestions += `\n\n전체 경로를 입력하거나 파일명을 확인해주세요.`;
+    }
+
+    return {
+      status: 'not_found',
+      suggestions
+    };
+  }
+
+  if (uniqueFiles.length === 1) {
+    return {
+      status: 'found',
+      path: uniqueFiles[0]
+    };
+  }
+
+  // 여러 파일 발견: 추가 분석 (키워드 전달)
+  const keywords = extracted?.keywords || [];
+  const candidates = await analyzeCandidates(uniqueFiles, keywords);
+
+  return {
+    status: 'multiple_candidates',
+    candidates
+  };
+}
+
+/**
+ * 파일에서 주석 추출 및 키워드 일치 검색
+ */
+function searchCommentsInFile(content: string, keywords: string[]): {
+  hasMatch: boolean;
+  matchedText?: string;
+  matchReason?: string;
+} {
+  // 주석 추출 (한 줄 주석과 여러 줄 주석 모두)
+  const commentPatterns = [
+    /\/\/.*$/gm,  // 한 줄 주석
+    /\/\*[\s\S]*?\*\//g,  // 여러 줄 주석
+  ];
+
+  let allComments = '';
+  for (const pattern of commentPatterns) {
+    const matches = content.match(pattern);
+    if (matches) {
+      allComments += ' ' + matches.join(' ');
+    }
+  }
+
+  // 키워드 일치 검색 (대소문자 구분 없이)
+  const lowerComments = allComments.toLowerCase();
+  const lowerContent = content.toLowerCase();
+
+  for (const keyword of keywords) {
+    const lowerKeyword = keyword.toLowerCase();
+
+    // 주석에서 키워드 검색
+    if (lowerComments.includes(lowerKeyword)) {
+      // 일치하는 텍스트 추출
+      const regex = new RegExp(`.{0,30}${keyword}.{0,30}`, 'i');
+      const match = allComments.match(regex);
+      const matchedText = match ? match[0].trim() : keyword;
+
+      return {
+        hasMatch: true,
+        matchedText,
+        matchReason: '주석에서 키워드 발견'
+      };
+    }
+
+    // 전체 내용에서 키워드 검색 (주석뿐만 아니라 클래스명, 메서드명 등도 포함)
+    if (lowerContent.includes(lowerKeyword)) {
+      return {
+        hasMatch: true,
+        matchedText: keyword,
+        matchReason: '파일 내용에서 키워드 발견'
+      };
+    }
+  }
+
+  return { hasMatch: false };
+}
+
+/**
+ * 후보 파일 분석 (주석 검색 포함)
+ */
+async function analyzeCandidates(filePaths: string[], inputKeywords: string[]) {
+  const candidates = await Promise.all(
+    filePaths.map(async (filePath) => {
+      try {
+        const content = await fs.readFile(filePath, 'utf-8');
+
+        // 간단한 분석: 메서드 수 추정
+        const methodMatches = content.match(/async (post|get|put|delete)\w*\(/g);
+        const methodCount = methodMatches?.length || 0;
+
+        // entityName 추정
+        const entityMatch = path.basename(filePath).match(/(\w+)Repository/);
+        const entityName = entityMatch ? entityMatch[1] : 'Unknown';
+
+        // 주석 검색
+        const commentMatch = searchCommentsInFile(content, inputKeywords);
+
+        return {
+          path: filePath,
+          methodCount,
+          entityName,
+          commentMatch
+        };
+      } catch {
+        return {
+          path: filePath,
+          methodCount: 0,
+          entityName: 'Unknown',
+          commentMatch: { hasMatch: false }
+        };
+      }
+    })
+  );
+
+  // 정렬 우선순위:
+  // 1. 주석 일치 (hasMatch: true)
+  // 2. 파일명 일치 (entityName이 키워드와 유사한지)
+  // 3. 메서드 수
+  return candidates.sort((a, b) => {
+    // 주석 일치 우선
+    if (a.commentMatch?.hasMatch && !b.commentMatch?.hasMatch) {
+      return -1;
+    }
+    if (!a.commentMatch?.hasMatch && b.commentMatch?.hasMatch) {
+      return 1;
+    }
+
+    // 둘 다 일치하거나 둘 다 불일치하면 파일명 유사도 확인
+    const aSimilarity = calculateSimilarity(a.entityName.toLowerCase(), inputKeywords.join(' ').toLowerCase());
+    const bSimilarity = calculateSimilarity(b.entityName.toLowerCase(), inputKeywords.join(' ').toLowerCase());
+
+    if (aSimilarity !== bSimilarity) {
+      return bSimilarity - aSimilarity; // 유사도 높은 것 우선
+    }
+
+    // 그 다음 메서드 수
+    if (a.entityName === b.entityName) {
+      return b.methodCount - a.methodCount;
+    }
+
+    return a.entityName.localeCompare(b.entityName);
+  });
+}
+
+/**
+ * 문자열 유사도 계산 (간단한 Levenshtein distance 기반)
+ */
+function calculateSimilarity(str1: string, str2: string): number {
+  const longer = str1.length > str2.length ? str1 : str2;
+  const shorter = str1.length > str2.length ? str2 : str1;
+
+  if (longer.length === 0) {
+    return 1.0;
+  }
+
+  const editDistance = levenshteinDistance(longer, shorter);
+  return (longer.length - editDistance) / longer.length;
+}
+
+/**
+ * Levenshtein distance 계산
+ */
+function levenshteinDistance(str1: string, str2: string): number {
+  const matrix = [];
+
+  for (let i = 0; i <= str2.length; i++) {
+    matrix[i] = [i];
+  }
+
+  for (let j = 0; j <= str1.length; j++) {
+    matrix[0][j] = j;
+  }
+
+  for (let i = 1; i <= str2.length; i++) {
+    for (let j = 1; j <= str1.length; j++) {
+      if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j] + 1
+        );
+      }
+    }
+  }
+
+  return matrix[str2.length][str1.length];
+}
+
+/**
+ * 프로젝트에서 기존 Store/Hook 파일이 있는 디렉토리 찾기
+ * @param projectRoot 프로젝트 루트 경로
+ * @param fileType 'store' 또는 'hook'
+ * @returns 찾은 디렉토리 경로 (절대 경로), 없으면 null
+ */
+async function findExistingDirectories(
+  projectRoot: string,
+  fileType: 'store' | 'hook'
+): Promise<string | null> {
+  try {
+    // 파일 패턴 정의
+    const filePatterns = fileType === 'store'
+      ? ['**/*Store.ts']  // Store만 찾기 (use*.ts 제거 - Hook과 혼동 방지)
+      : ['**/use*Service.ts', '**/use*.ts'];
+
+    // 디렉토리 후보 수집
+    const dirCandidates = new Map<string, number>(); // 경로 -> 파일 수
+
+    for (const pattern of filePatterns) {
+      const files = await glob(pattern, {
+        cwd: projectRoot,
+        absolute: true,
+        ignore: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.next/**', '**/test/**'],
+      });
+
+      // 파일이 있는 디렉토리 수집
+      for (const file of files) {
+        const dir = path.dirname(file);
+        const relativePath = path.relative(projectRoot, dir);
+        const depth = relativePath.split(path.sep).length;
+
+        // depth가 2-5 사이인 것만 (너무 깊거나 얕은 것 제외)
+        if (depth >= 1 && depth <= 5) {
+          dirCandidates.set(dir, (dirCandidates.get(dir) || 0) + 1);
+        }
+      }
+    }
+
+    if (dirCandidates.size === 0) {
+      return null;
+    }
+
+    // 파일 수가 가장 많은 디렉토리 반환
+    const sortedDirs = Array.from(dirCandidates.entries())
+      .sort((a, b) => b[1] - a[1]); // 파일 수 내림차순
+
+    return sortedDirs[0][0];
+  } catch {
+    // 실패 시 null 반환
+  }
+  return null;
+}
+
+/**
+ * 경로 제안 (프로젝트 스캔 기반)
+ */
+async function suggestPaths(
+  repositoryPath: string,
+  projectRoot: string,
+  entityName: string
+): Promise<PathSuggestions> {
+  // 1. Repository 경로 분석
+  const repoDir = path.dirname(repositoryPath);
+
+  // 2. 기존 stores 폴더 찾기
+  const existingStoresDir = await findExistingDirectories(projectRoot, 'store');
+
+  // 3. 기존 hooks 폴더 찾기
+  const existingHooksDir = await findExistingDirectories(projectRoot, 'hook');
+
+  // 4. Store 경로 결정
+  let storePath: string;
+  if (existingStoresDir) {
+    storePath = path.join(existingStoresDir, `use${entityName}ListStore.ts`);
+  } else {
+    // 기본 경로: Repository의 상위 폴더 기준
+    // src/services/repository/member/MemberRepository.ts → src/stores/
+    const srcDir = repoDir.split(path.sep).includes('src')
+      ? repoDir.split(path.sep).slice(0, repoDir.split(path.sep).indexOf('src') + 1).join(path.sep)
+      : path.dirname(repoDir);
+    storePath = path.join(srcDir, 'stores', `use${entityName}ListStore.ts`);
+  }
+
+  // 5. Hook 경로 결정
+  let hookPath: string;
+  if (existingHooksDir) {
+    hookPath = path.join(existingHooksDir, `use${entityName}Service.ts`);
+  } else {
+    // 기본 경로
+    const srcDir = repoDir.split(path.sep).includes('src')
+      ? repoDir.split(path.sep).slice(0, repoDir.split(path.sep).indexOf('src') + 1).join(path.sep)
+      : path.dirname(repoDir);
+    hookPath = path.join(srcDir, 'hooks', `use${entityName}Service.ts`);
+  }
+
+  return {
+    storePath: path.relative(projectRoot, storePath),
+    hookPath: path.relative(projectRoot, hookPath),
+    repositoryPath: path.relative(projectRoot, repositoryPath)
+  };
+}
+
+/**
+ * 파일 요약 포맷 (주석 일치 정보 포함)
+ */
+function formatFileSummary(candidate: {
+  path: string;
+  methodCount?: number;
+  entityName?: string;
+  commentMatch?: { hasMatch: boolean; matchedText?: string; matchReason?: string };
+}): string {
+  const fileName = path.basename(candidate.path);
+  const methodCount = candidate.methodCount || 0;
+  const entityName = candidate.entityName || 'Unknown';
+  const commentMatch = candidate.commentMatch;
+
+  let summary = `${fileName} (${entityName}, ${methodCount}개 API)`;
+
+  // 주석 일치 정보 추가
+  if (commentMatch?.hasMatch) {
+    const icon = commentMatch.matchReason === '주석에서 키워드 발견' ? '💡' : '🔍';
+    summary += ` ${icon}`;
+    if (commentMatch.matchedText) {
+      summary += ` - "${commentMatch.matchedText}"`;
+    }
+  }
+
+  return summary;
+}
+
+/**
+ * 응답 생성
+ */
+function createResponse(response: InteractiveResponse): { content: Array<{ type: string; text: string }> } {
+  return {
+    content: [{
+      type: 'text',
+      text: formatInteractiveResponse(response)
+    }]
+  };
+}
+
+/**
+ * 대화형 응답 포맷
+ */
+function formatInteractiveResponse(response: InteractiveResponse): string {
+  const lines: string[] = [];
+
+  // 자연어 분석 헤더
+  if (response.naturalLanguageInfo && response.naturalLanguageInfo.detectedKeywords.length > 0) {
+    const info = response.naturalLanguageInfo;
+    lines.push('🔍 자연어 분석:');
+    lines.push(`   "${info.originalInput}" → ${info.matchedCandidates.join(' 또는 ')}\n`);
+  }
+
+  if (response.status === 'complete') {
+    const result = response.result!;
+    lines.push('✅ Store 및 Hook 생성 완료\n');
+    lines.push(`Store: ${result.storePath}`);
+    lines.push(`  → ${result.storeStatus}`);
+    lines.push(`Hook: ${result.hookPath}`);
+    lines.push(`  → ${result.hookStatus}`);
+
+    if (result.storeErrors && result.storeErrors.length > 0) {
+      lines.push('\nStore 타입 오류:');
+      result.storeErrors.forEach(err => lines.push(`  - ${err}`));
+    }
+
+    if (result.hookErrors && result.hookErrors.length > 0) {
+      lines.push('\nHook 타입 오류:');
+      result.hookErrors.forEach(err => lines.push(`  - ${err}`));
+    }
+  }
+  else if (response.status === 'need_file_selection') {
+    lines.push('📁 발견된 Repository 파일:\n');
+
+    response.fileCandidates!.forEach(candidate => {
+      lines.push(`   ${candidate.index}. ${candidate.summary}`);
+      lines.push(`      경로: ${candidate.relativePath}`);
+    });
+
+    lines.push('\n[중요] 위 목록에서 사용할 파일의 번호를 입력받으세요.');
+    lines.push('[중요] 사용자가 번호를 입력하기 전까지는 fileIndex를 설정하거나 파일을 선택하지 마세요.');
+  }
+  else if (response.status === 'need_path_confirmation') {
+    const info = response.selectedFileInfo!;
+    const paths = response.pathSuggestions!;
+
+    lines.push(`📁 선택된 파일: ${info.fileName} (${info.entityName}, ${info.methodCount}개 API)\n`);
+    lines.push('📂 생성 경로 제안:\n');
+    lines.push(`   Store: ${paths.storePath}`);
+    lines.push(`   Hook:  ${paths.hookPath}\n`);
+    lines.push('[선택사항]\n');
+    lines.push('1. 제안된 경로로 생성 → "확인" 또는 "진행" 입력');
+    lines.push('2. 경로 변경 후 생성 → 변경할 경로 입력:');
+    lines.push(`   - Store만: "store는 src/stores/useBannerStore.ts로"`);
+    lines.push(`   - Hook만: "hook은 src/hooks/useBannerService.ts로"`);
+    lines.push(`   - 둘 다: "store는 src/stores/useBannerStore.ts, hook은 src/hooks/useBannerService.ts로"`);
+    lines.push('\n[중요] 사용자가 "확인", "진행" 또는 경로를 입력하기 전까지는 파일을 생성하지 마세요.');
+  }
+  else if (response.status === 'error') {
+    lines.push('❌ 오류\n');
+    lines.push(response.error || '알 수 없는 오류가 발생했습니다.');
+  }
+
+  return lines.join('\n');
+}