@axboot-mcp/mcp-server 1.0.0

package/scripts/batch-process.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""
+Batch Store Generator using MCP-AXBOOT
+Processes all repositories and generates Zustand stores
+"""
+
+import json
+import sys
+import subprocess
+import os
+from pathlib import Path
+
+# Load the repository list
+plan_file = Path(__file__).parent / 'repos-to-process.json'
+with open(plan_file) as f:
+    repositories = json.load(f)
+
+print(f"Total repositories to process: {len(repositories)}")
+print("=" * 80)
+
+# Track results
+results = {
+    "success": [],
+    "failed": [],
+    "skipped": []
+}
+
+# Process each repository
+for i, repo in enumerate(repositories, 1):
+    repo_name = repo['repositoryName']
+    store_name = repo['storeName']
+    input_path = repo['inputPath']
+    output_path = repo['outputPath']
+    store_type = repo['storeType']
+
+    print(f"\n[{i}/{len(repositories)}] Processing: {repo_name}")
+    print(f"  Store: {store_name}")
+    print(f"  Type: {store_type}")
+    print(f"  Input: {input_path}")
+    print(f"  Output: {output_path}")
+
+    # Check if input file exists
+    if not os.path.exists(input_path):
+        print(f"  ⚠️  SKIP: Input file not found")
+        results["skipped"].append({
+            "repository": repo_name,
+            "reason": "Input file not found"
+        })
+        continue
+
+    # Check if file is empty
+    if os.path.getsize(input_path) == 0:
+        print(f"  ⚠️  SKIP: Empty file")
+        results["skipped"].append({
+            "repository": repo_name,
+            "reason": "Empty file"
+        })
+        continue
+
+    try:
+        # For now, we'll create a placeholder file
+        # In the next step, we'll use the MCP tool
+        print(f"  ✓ Would generate store (type {store_type})")
+        results["success"].append({
+            "repository": repo_name,
+            "store": store_name,
+            "type": store_type
+        })
+    except Exception as e:
+        print(f"  ❌ ERROR: {str(e)}")
+        results["failed"].append({
+            "repository": repo_name,
+            "error": str(e)
+        })
+
+# Print summary
+print("\n" + "=" * 80)
+print("SUMMARY")
+print("=" * 80)
+print(f"Total: {len(repositories)}")
+print(f"✓ Success: {len(results['success'])}")
+print(f"⚠️  Skipped: {len(results['skipped'])}")
+print(f"❌ Failed: {len(results['failed'])}")
+
+# Save results
+results_file = Path(__file__).parent / 'processing-results.json'
+with open(results_file, 'w') as f:
+    json.dump(results, f, indent=2)
+
+print(f"\nResults saved to: {results_file}")

package/scripts/batch-regenerate.js

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+/**
+ * NH 프로젝트 Store 일괄 재생성 스크립트
+ *
+ * 1. NH 폴더 하위의 모든 use*Store.ts 파일 찾기
+ * 2. Service 이름 추출
+ * 3. Repository 찾기
+ * 4. MCP 서버로 Store 재생성
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const TARGET_DIR = '/Users/kyle/Desktop/nh-fe-bo/src/pages/resources/NH';
+const REPO_BASE = '/Users/kyle/Desktop/nh-fe-bo/src/services/@interface/repository';
+const MCP_SERVER_PATH = '/Users/kyle/work/mcp-axboot/dist/index.js';
+
+// ANSI 색상
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+};
+
+function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+/**
+ * Store 파일에서 Service 이름 추출
+ * 예: import { Banner, BannerSerevice, ... } from "services"; → BannerSerevice
+ */
+function extractServiceName(storeContent) {
+  // "from "services"" 라인 찾기
+  const servicesImportMatch = storeContent.match(/import\s*{[^}]*}\s*from\s*['"]services['"];?/);
+  if (!servicesImportMatch) return null;
+
+  const imports = servicesImportMatch[0];
+  // Service 이름 패턴: XxxService 또는 XxxSerevice (오타 포함)
+  const serviceMatch = imports.match(/([A-Z][a-zA-Z0-9]*)Serevice\b/);
+  if (serviceMatch) {
+    return serviceMatch[1] + 'Serevice'; // 오타 그대로 사용
+  }
+
+  const serviceMatch2 = imports.match(/([A-Z][a-zA-Z0-9]*)Service\b/);
+  return serviceMatch2 ? serviceMatch2[1] + 'Service' : null;
+}
+
+/**
+ * Service 이름으로 Repository 파일 찾기
+ * 예: BannerSerevice → BannerRepository.ts
+ */
+function findRepository(serviceName) {
+  // Service 이름에서 Entity 이름 추출
+  // BannerSerevice → Banner, MemberService → Member
+  const entityMatch = serviceName.match(/([A-Z][a-zA-Z0-9]*)Serevice/)
+    || serviceName.match(/([A-Z][a-zA-Z0-9]*)Service/);
+
+  if (!entityMatch) return null;
+
+  const entityName = entityMatch[1];
+
+  // 가능한 Repository 파일 이름들
+  const possibleNames = [
+    `${entityName}Repository.ts`,
+    `${entityName}Interface.ts`,
+  ];
+
+  for (const name of possibleNames) {
+    const repoPath = path.join(REPO_BASE, name);
+    if (fs.existsSync(repoPath)) {
+      return { repoPath, entityName };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Store 파일에서 패턴 분석으로 Store 타입 결정
+ */
+function detectStoreType(storeContent) {
+  const hasList = /callListApi/.test(storeContent);
+  const hasDetail = /callDetailApi|setDetail|detail:/.test(storeContent);
+  const hasDelete = /callDeleteApi|deleteSpinning/.test(storeContent);
+  const hasSave = /callSaveApi|saveSpinning/.test(storeContent);
+  const hasExcel = /callExcelDownloadApi|excelSpinning/.test(storeContent);
+  const hasModal = /modalOpen|setModalOpen/.test(storeContent);
+  const hasTree = /expandedKeys|setExpandedKeys/.test(storeContent);
+  const hasDashboard = /summaryData|summarySpinning/.test(storeContent);
+  const hasReorder = /setListData.*drag|isReordered/.test(storeContent);
+
+  // 대시보드
+  if (hasDashboard) return 4; // Type 4
+
+  // 트리
+  if (hasTree) return 3; // Type 3
+
+  // 재정렬
+  if (hasReorder && !hasDetail && !hasDelete && !hasSave) return 6; // Type 6
+
+  // 단순 리스트
+  if (!hasDetail && !hasDelete && !hasSave && !hasExcel && !hasModal) return 5; // Type 5
+
+  // Master-Detail + Excel
+  if (hasList && hasExcel && !hasModal && !hasDelete && !hasSave) return 10; // Type 10
+
+  // List + Selection + Excel
+  if (hasList && hasExcel && !hasDetail && !hasModal) return 8; // Type 8
+
+  // Master-Detail + Modal + Delete + Excel
+  if (hasList && hasDetail && hasModal && hasDelete && hasExcel) return 7; // Type 7
+
+  // Master-Detail + Modal + Detail API
+  if (hasList && hasDetail && hasModal && !hasDelete && !hasSave && !hasExcel) return 9; // Type 9
+
+  // Master-Detail + Modal + Delete (기본)
+  if (hasList && hasDetail && hasModal && hasDelete) return 2; // Type 2
+
+  // 기본 리스트 + 상세
+  if (hasList && hasDetail) return 1; // Type 1
+
+  // 기본값
+  return 1;
+}
+
+/**
+ * MCP 서버로 Store 생성 요청
+ */
+async function generateStore(repoPath, outputPath, storeName, storeType) {
+  const { spawn } = require('child_process');
+
+  return new Promise((resolve, reject) => {
+    const MCP_SERVER = spawn('node', [MCP_SERVER_PATH], {
+      stdio: ['pipe', 'pipe', 'inherit'],
+    });
+
+    let responseData = '';
+    let requestId = 1;
+
+    MCP_SERVER.stdout.on('data', (data) => {
+      responseData += data.toString();
+    });
+
+    MCP_SERVER.on('error', (error) => {
+      reject(error);
+    });
+
+    MCP_SERVER.on('close', (code) => {
+      try {
+        const responses = responseData.trim().split('\n').filter(Boolean);
+        for (const response of responses) {
+          const parsed = JSON.parse(response);
+          if (parsed.result) {
+            resolve(parsed.result);
+            return;
+          }
+        }
+        reject(new Error('No valid response from MCP server'));
+      } catch (e) {
+        reject(e);
+      }
+    });
+
+    // initialize
+    MCP_SERVER.stdin.write(JSON.stringify({
+      jsonrpc: '2.0',
+      id: requestId++,
+      method: 'initialize',
+      params: {
+        protocolVersion: '2024-11-05',
+        capabilities: {},
+        clientInfo: {
+          name: 'batch-regenerate-script',
+          version: '1.0.0',
+        },
+      },
+    }) + '\n');
+
+    // tools/list
+    MCP_SERVER.stdin.write(JSON.stringify({
+      jsonrpc: '2.0',
+      id: requestId++,
+      method: 'tools/list',
+    }) + '\n');
+
+    // generate_store 호출
+    setTimeout(() => {
+      MCP_SERVER.stdin.write(JSON.stringify({
+        jsonrpc: '2.0',
+        id: requestId++,
+        method: 'tools/call',
+        params: {
+          name: 'generate_store',
+          arguments: {
+            interfacePath: repoPath,
+            outputPath: outputPath,
+            storeName: storeName,
+            storeType: storeType,
+          },
+        },
+      }) + '\n');
+    }, 100);
+
+    setTimeout(() => {
+      MCP_SERVER.kill();
+    }, 10000);
+  });
+}
+
+/**
+ * 메인 처리 함수
+ */
+async function processStore(storePath) {
+  const content = fs.readFileSync(storePath, 'utf8');
+
+  // Service 이름 추출
+  const serviceName = extractServiceName(content);
+  if (!serviceName) {
+    log(`  ⚠️  Service를 찾을 수 없음`, 'yellow');
+    return { success: false, reason: 'No service found' };
+  }
+
+  // Repository 찾기
+  const repoInfo = findRepository(serviceName);
+  if (!repoInfo) {
+    log(`  ⚠️  Repository를 찾을 수 없음 (${serviceName})`, 'yellow');
+    return { success: false, reason: 'No repository found', serviceName };
+  }
+
+  const { repoPath, entityName } = repoInfo;
+
+  // 새 Store 이름 생성
+  const storeDir = path.dirname(storePath);
+  const originalName = path.basename(storePath, '.ts');
+  const newStoreName = originalName.replace('use', 'use').replace('Store', 'StoreNew');
+  const outputPath = path.join(storeDir, `${newStoreName}.ts`);
+
+  // Store 타입 결정
+  const storeType = detectStoreType(content);
+
+  log(`  📦 Entity: ${entityName}`, 'cyan');
+  log(`  📝 Repository: ${path.basename(repoPath)}`, 'cyan');
+  log(`  🔧 Store Type: ${storeType}`, 'cyan');
+  log(`  📄 Output: ${newStoreName}.ts`, 'cyan');
+
+  try {
+    await generateStore(repoPath, outputPath, newStoreName, storeType);
+    log(`  ✅ 생성 완료`, 'green');
+    return {
+      success: true,
+      entityName,
+      serviceName,
+      originalName,
+      newName: newStoreName,
+      storeType,
+    };
+  } catch (error) {
+    log(`  ❌ 생성 실패: ${error.message}`, 'red');
+    return {
+      success: false,
+      reason: 'Generation failed',
+      error: error.message,
+    };
+  }
+}
+
+/**
+ * 메인 실행
+ */
+async function main() {
+  log('='.repeat(60), 'cyan');
+  log('NH 프로젝트 Store 일괄 재생성', 'bright');
+  log('='.repeat(60), 'cyan');
+
+  // MCP 서버 확인
+  if (!fs.existsSync(MCP_SERVER_PATH)) {
+    log(`❌ MCP 서버를 찾을 수 없음: ${MCP_SERVER_PATH}`, 'red');
+    log('먼저 npm run build를 실행해주세요.', 'yellow');
+    process.exit(1);
+  }
+
+  // 모든 Store 파일 찾기
+  const findCommand = `find "${TARGET_DIR}" -name "use*Store.ts" -type f`;
+  let storeFiles;
+  try {
+    storeFiles = execSync(findCommand, { encoding: 'utf8' }).trim().split('\n');
+  } catch (error) {
+    log(`❌ Store 파일을 찾을 수 없음: ${TARGET_DIR}`, 'red');
+    process.exit(1);
+  }
+
+  log(`\n📊 총 ${storeFiles.length}개의 Store 파일 발견\n`, 'bright');
+
+  const results = {
+    total: storeFiles.length,
+    success: 0,
+    failed: 0,
+    noService: 0,
+    noRepo: 0,
+    details: [],
+  };
+
+  // 각 Store 처리
+  for (let i = 0; i < storeFiles.length; i++) {
+    const storePath = storeFiles[i];
+    const relativePath = path.relative(TARGET_DIR, storePath);
+
+    process.stdout.write(`\r[${i + 1}/${storeFiles.length}] ${relativePath.padEnd(50)} `);
+
+    const result = await processStore(storePath);
+
+    results.details.push({ ...result, path: relativePath });
+
+    if (result.success) {
+      results.success++;
+    } else {
+      results.failed++;
+      if (result.reason === 'No service found') results.noService++;
+      if (result.reason === 'No repository found') results.noRepo++;
+    }
+  }
+
+  // 결과 요약
+  log('\n');
+  log('='.repeat(60), 'cyan');
+  log('📊 결과 요약', 'bright');
+  log('='.repeat(60), 'cyan');
+  log(`  전체: ${results.total}`, 'cyan');
+  log(`  성공: ${results.success}`, 'green');
+  log(`  실패: ${results.failed}`, 'red');
+  log(`    - Service 없음: ${results.noService}`, 'yellow');
+  log(`    - Repository 없음: ${results.noRepo}`, 'yellow');
+  log('='.repeat(60), 'cyan');
+
+  // 실패 목록
+  if (results.details.filter(r => !r.success && r.reason !== 'No service found' && r.reason !== 'No repository found').length > 0) {
+    log('\n⚠️  생성 실패 목록:', 'yellow');
+    results.details
+      .filter(r => !r.success && r.reason !== 'No service found' && r.reason !== 'No repository found')
+      .forEach(r => {
+        log(`  ❌ ${r.path}: ${r.error || r.reason}`, 'red');
+      });
+  }
+}
+
+main().catch(error => {
+  log(`\n❌ 치명적 오류: ${error.message}`, 'red');
+  console.error(error);
+  process.exit(1);
+});

package/scripts/direct-generate.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+
+// Direct import of handlers to avoid MCP protocol overhead
+import { generateStore } from '../dist/handlers/generate.js';
+import fs from 'fs';
+import path from 'path';
+
+const SOURCE_DIR = '/Users/kyle/Desktop/nh-fe-bo/src/services/@interface/repository';
+const OUTPUT_DIR = '/Users/kyle/Desktop/nh-fe-bo/src/pages/resources/NH/test';
+
+// Store type detection patterns
+function detectStoreType(filePath) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const methods = content.match(/async\s+(\w+)\s*\(/g) || [];
+  const methodNames = methods.map(m => m.match(/async\s+(\w+)/)[1].toLowerCase());
+
+  const hasList = methodNames.some(m => m.includes('list'));
+  const hasDetail = methodNames.some(m => m.includes('detail') || m.includes('dtl'));
+  const hasSave = methodNames.some(m => m.includes('save'));
+  const hasDelete = methodNames.some(m => m.includes('delete') || m.includes('del'));
+  const hasExcel = methodNames.some(m => m.includes('excel') || m.includes('download') || m.includes('export'));
+
+  if (hasList && hasDetail && hasSave && hasDelete && hasExcel) {
+    return 7;
+  } else if (hasList && hasDetail && hasSave && hasDelete) {
+    return 2;
+  } else if (hasList && hasSave) {
+    return 1;
+  } else {
+    return 5;
+  }
+}
+
+// Get all repository files
+function getRepositoryFiles() {
+  const files = fs.readdirSync(SOURCE_DIR)
+    .filter(file => file.endsWith('Repository.ts'));
+  return files.map(file => path.join(SOURCE_DIR, file));
+}
+
+// Extract repository name
+function getRepositoryName(filePath) {
+  return path.basename(filePath, 'Repository.ts');
+}
+
+// Generate store name
+function getStoreName(repositoryName) {
+  return `use${repositoryName}ListStore`;
+}
+
+// Get output path
+function getOutputPath(repositoryName) {
+  return path.join(OUTPUT_DIR, `use${repositoryName}ListStore.ts`);
+}
+
+// Main execution
+async function main() {
+  console.log('='.repeat(80));
+  console.log('Batch Store Generation for NH-FE-BO Repository Files');
+  console.log('='.repeat(80));
+  console.log(`Source Directory: ${SOURCE_DIR}`);
+  console.log(`Output Directory: ${OUTPUT_DIR}`);
+  console.log('');
+
+  const files = getRepositoryFiles();
+  console.log(`Found ${files.length} repository files\n`);
+
+  const results = {
+    total: files.length,
+    success: 0,
+    failed: 0,
+    skipped: 0,
+    generated: [],
+    failedFiles: [],
+    typeDistribution: {}
+  };
+
+  // Process in batches of 10
+  const batchSize = 10;
+  for (let i = 0; i < files.length; i += batchSize) {
+    const batch = files.slice(i, i + batchSize);
+    console.log(`\nProcessing batch ${Math.floor(i/batchSize) + 1}/${Math.ceil(files.length/batchSize)} (files ${i + 1}-${Math.min(i + batchSize, files.length)})`);
+    console.log('-'.repeat(80));
+
+    for (const filePath of batch) {
+      const index = files.indexOf(filePath) + 1;
+      const repositoryName = getRepositoryName(filePath);
+      const storeName = getStoreName(repositoryName);
+      const outputPath = getOutputPath(repositoryName);
+      const storeType = detectStoreType(filePath);
+
+      // Track type distribution
+      results.typeDistribution[storeType] = (results.typeDistribution[storeType] || 0) + 1;
+
+      console.log(`[${index}/${files.length}] ${repositoryName}Repository → Type ${storeType}`);
+
+      try {
+        // Check if file already exists
+        if (fs.existsSync(outputPath)) {
+          console.log(`  ⚠️  Already exists, skipping\n`);
+          results.skipped++;
+          results.generated.push({
+            repositoryName,
+            storeName,
+            storeType,
+            status: 'exists',
+            outputPath
+          });
+          continue;
+        }
+
+        // Generate store using direct handler call
+        console.log(`  🔄 Generating store...`);
+        const result = await generateStore({
+          interfacePath: filePath,
+          outputPath: outputPath,
+          storeType: storeType,
+          storeName: storeName
+        });
+
+        // Parse result
+        let resultData;
+        if (result.content && result.content[0]) {
+          resultData = JSON.parse(result.content[0].text);
+        } else {
+          throw new Error('Invalid response format');
+        }
+
+        if (!resultData.success) {
+          throw new Error(resultData.error || 'Unknown error');
+        }
+
+        // Check if file was created
+        if (fs.existsSync(outputPath)) {
+          results.success++;
+          results.generated.push({
+            repositoryName,
+            storeName,
+            storeType,
+            status: 'success',
+            outputPath
+          });
+          console.log(`  ✓ Generated\n`);
+        } else {
+          throw new Error('File was not created');
+        }
+
+      } catch (error) {
+        results.failed++;
+        results.failedFiles.push({
+          repositoryName,
+          storeName,
+          error: error.message
+        });
+        console.log(`  ✗ Failed: ${error.message}\n`);
+      }
+
+      // Small delay
+      await new Promise(resolve => setTimeout(resolve, 50));
+    }
+  }
+
+  // Print summary
+  console.log('\n' + '='.repeat(80));
+  console.log('SUMMARY');
+  console.log('='.repeat(80));
+  console.log(`Total files processed: ${results.total}`);
+  console.log(`Successfully generated: ${results.success}`);
+  console.log(`Skipped (already exists): ${results.skipped}`);
+  console.log(`Failed: ${results.failed}`);
+  console.log('');
+  console.log('Type Distribution:');
+  Object.entries(results.typeDistribution).sort((a, b) => a[0] - b[0]).forEach(([type, count]) => {
+    console.log(`  Type ${type}: ${count} files`);
+  });
+
+  // Save detailed results
+  const resultsPath = path.join(OUTPUT_DIR, 'generation-results.json');
+  fs.writeFileSync(resultsPath, JSON.stringify(results, null, 2));
+  console.log(`\nDetailed results saved to: ${resultsPath}`);
+
+  // Generate markdown report
+  const markdownPath = path.join(OUTPUT_DIR, 'generation-results.md');
+  const markdown = generateMarkdownReport(results);
+  fs.writeFileSync(markdownPath, markdown);
+  console.log(`Markdown report saved to: ${markdownPath}`);
+}
+
+function generateMarkdownReport(results) {
+  const date = new Date().toISOString();
+
+  let md = `# Store Generation Results\n\n`;
+  md += `**Generated:** ${date}\n\n`;
+  md += `## Summary\n\n`;
+  md += `- **Total Files:** ${results.total}\n`;
+  md += `- **Successfully Generated:** ${results.success}\n`;
+  md += `- **Skipped (already exists):** ${results.skipped}\n`;
+  md += `- **Failed:** ${results.failed}\n\n`;
+
+  md += `## Type Distribution\n\n`;
+  md += `| Type | Count |\n`;
+  md += `|------|-------|\n`;
+  Object.entries(results.typeDistribution).sort((a, b) => a[0] - b[0]).forEach(([type, count]) => {
+    md += `| ${type} | ${count} |\n`;
+  });
+
+  md += `\n## Generated Stores\n\n`;
+  md += `| # | Repository | Store Name | Type | Status |\n`;
+  md += `|---|------------|------------|------|--------|\n`;
+  results.generated.forEach((item, idx) => {
+    const status = item.status === 'success' ? '✓' : '⚠️';
+    md += `| ${idx + 1} | ${item.repositoryName}Repository | ${item.storeName} | ${item.storeType} | ${status} |\n`;
+  });
+
+  if (results.failedFiles.length > 0) {
+    md += `\n## Failed Files\n\n`;
+    md += `| Repository | Error |\n`;
+    md += `|------------|-------|\n`;
+    results.failedFiles.forEach(item => {
+      md += `| ${item.repositoryName} | ${item.error} |\n`;
+    });
+  }
+
+  return md;
+}
+
+main().catch(console.error);