@axboot-mcp/mcp-server 1.0.0

package/scripts/generate-all-stores.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+/**
+ * Generate All Stores Script
+ *
+ * Uses mcp-axboot MCP tools to generate Zustand stores from Repository files
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Configuration
+const REPO_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';
+const MCP_SERVER_PATH = '/Users/kyle/work/mcp-axboot/dist/index.js';
+
+// Get all repository files
+const repoFiles = fs.readdirSync(REPO_DIR)
+  .filter(f => f.endsWith('Repository.ts'))
+  .sort();
+
+console.log(`Found ${repoFiles.length} repository files`);
+
+// Build the MCP server first
+console.log('Building MCP server...');
+execSync('npm run build', { cwd: '/Users/kyle/work/mcp-axboot', stdio: 'inherit' });
+
+// Function to generate store name from repository name
+function getStoreName(repoName) {
+  const baseName = repoName.replace('Repository', '');
+  return `use${baseName}ListStore`;
+}
+
+// Function to determine store type based on content
+function determineStoreType(content) {
+  const hasList = /\b(list|find|search)\b/i.test(content);
+  const hasDetail = /\b(detail|dtlinfo|get)\b/i.test(content);
+  const hasSave = /\b(save|update|insert|create|modify|regist)\b/i.test(content);
+  const hasDelete = /\b(delete|remove)\b/i.test(content);
+  const hasExcel = /\b(excel|export|download)\b/i.test(content);
+
+  // Type 7: Master-Detail + Modal + Delete + Excel
+  if (hasList && hasDetail && hasSave && hasDelete && hasExcel) return 7;
+  // Type 2: Master-Detail + Modal + Delete
+  if (hasList && hasDetail && hasSave && hasDelete) return 2;
+  // Type 1: Basic List + Detail
+  if (hasList && hasSave) return 1;
+  // Type 5: Simple List (default)
+  return 5;
+}
+
+// Process each repository
+const results = [];
+
+for (let i = 0; i < repoFiles.length; i++) {
+  const repoFile = repoFiles[i];
+  const repoName = repoFile.replace('.ts', '');
+  const inputPath = path.join(REPO_DIR, repoFile);
+  const storeName = getStoreName(repoName);
+  const outputPath = path.join(OUTPUT_DIR, `${storeName}.ts`);
+
+  try {
+    const content = fs.readFileSync(inputPath, 'utf-8');
+    const storeType = determineStoreType(content);
+
+    console.log(`${i + 1}/${repoFiles.length}: ${repoName} -> Type ${storeType}`);
+
+    // Import the generate function from the built MCP server
+    const { generateStoreFromInterface } = require('../dist/handlers/generate');
+
+    // Read the interface file
+    const interfaceContent = fs.readFileSync(inputPath, 'utf-8');
+
+    // Extract the interface name (usually XxxxInterface)
+    const interfaceMatch = interfaceContent.match(/implements\s+(\w+Interface)/);
+    const interfaceName = interfaceMatch ? interfaceMatch[1] : null;
+
+    if (!interfaceName) {
+      console.log(`   Skipped: No interface found`);
+      results.push({ repository: repoName, status: 'skipped', reason: 'No interface' });
+      continue;
+    }
+
+    // Generate the store
+    const template = require(`../dist/templates/type${storeType + 1}`);
+
+    // Extract variable names from interface
+    const classNameMatch = interfaceContent.match(/export\s+class\s+(\w+)\s+extends/);
+    const className = classNameMatch ? classNameMatch[1] : '';
+
+    // Extract DTO types from methods
+    const responseMatches = interfaceContent.matchAll(/this\._apiWrapper<(\w+)>/g);
+    const responseTypes = [...responseMatches].map(m => m[1]);
+    const uniqueResponseTypes = [...new Set(responseTypes)];
+
+    // Determine main DTO type (usually the list response type)
+    const mainDto = uniqueResponseTypes.find(t => t.includes('Response') || t.includes('List')) || uniqueResponseTypes[0] || 'any';
+
+    // Prepare template variables
+    const templateVars = {
+      STORE_NAME: storeName,
+      DTO_NAME: mainDto.replace('Response', 'Res').replace('Request', 'Req'),
+      REPOSITORY_NAME: className,
+      INTERFACE_NAME: interfaceName,
+      ROW_KEY: 'id',
+    };
+
+    // Generate store code
+    const storeCode = template(templateVars);
+
+    // Write to output file
+    fs.writeFileSync(outputPath, storeCode, 'utf-8');
+
+    results.push({
+      repository: repoName,
+      storeName,
+      storeType,
+      status: 'success',
+      outputPath
+    });
+
+    console.log(`   Generated: ${outputPath}`);
+
+  } catch (error) {
+    console.error(`   Error: ${error.message}`);
+    results.push({
+      repository: repoName,
+      status: 'failed',
+      error: error.message
+    });
+  }
+}
+
+// Generate summary report
+const successCount = results.filter(r => r.status === 'success').length;
+const failCount = results.filter(r => r.status === 'failed').length;
+
+console.log('\n' + '='.repeat(60));
+console.log('Summary');
+console.log('='.repeat(60));
+console.log(`Total: ${repoFiles.length}`);
+console.log(`Success: ${successCount}`);
+console.log(`Failed: ${failCount}`);

package/scripts/generate-stores-mcp.js

@@ -0,0 +1,161 @@
+/**
+ * MCP 서버를 사용하여 NH 폴더별 Store 파일 생성
+ * 각 폴더에 맞는 Repository를 찾아서 동일 위치에 Store 생성
+ */
+
+const { generateStore } = require('../dist/handlers/generate.js');
+const { analyzeInterface } = require('../dist/handlers/analyze.js');
+const fs = require('fs');
+const path = require('path');
+
+const NH_DIR = '/Users/kyle/Desktop/nh-fe-bo/src/pages/resources/NH';
+const REPO_DIR = '/Users/kyle/Desktop/nh-fe-bo/src/services/@interface/repository';
+
+// 폴더 이름 → Repository 이름 매핑 규칙
+function folderToRepoName(folderName) {
+  // kebab-case 또는 dot.case를 PascalCase로 변환
+  // 예: b2b.estimate-consulting → B2bEstimateConsulting
+  // 예: benefit.mileage-daily-summary → BenefitMileageDailySummary
+
+  // 점과 하이픈을 모두 제거하고 각 단어를 PascalCase로 변환
+  return folderName
+    .split(/[\.-]/)
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('');
+}
+
+// Repository 파일 존재 확인 (개선된 매칭)
+function findRepository(folderName) {
+  // 기존 Store 파일이 있는 위치를 참고하여 매핑
+  const existingStoreMapping = getExistingStoreMapping();
+
+  if (existingStoreMapping[folderName]) {
+    const repoPath = path.join(REPO_DIR, existingStoreMapping[folderName]);
+    if (fs.existsSync(repoPath)) {
+      return repoPath;
+    }
+  }
+
+  return null;
+}
+
+// 기존 Store 파일 위치에서 Repository 매핑 추론
+function getExistingStoreMapping() {
+  const mappings = {};
+
+  // 기존에 생성된 StoreNew 파일 스캔
+  const scanStores = (dir) => {
+    if (!fs.existsSync(dir)) return;
+
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        scanStores(path.join(dir, entry.name));
+      } else if (entry.name.endsWith('StoreNew.ts')) {
+        // StoreNew 파일에서 Service 이름 추출
+        const storePath = path.join(dir, entry.name);
+        const storeContent = fs.readFileSync(storePath, 'utf-8');
+
+        // Service import에서 추출: import { ..., XxxService, ... } from "services";
+        const serviceMatches = storeContent.matchAll(/import\s*\{([^}]+)\}\s*from\s*"services"/g);
+        for (const serviceMatch of serviceMatches) {
+          const imports = serviceMatch[1];
+          // 모든 Service 찾기
+          const individualServices = imports.matchAll(/(\w+Service)/g);
+          for (const sMatch of individualServices) {
+            const serviceName = sMatch[1];
+            // "Service"로 끝나는 전체 이름인지 확인
+            if (serviceName && serviceName.endsWith('Service')) {
+              const repoName = serviceName.replace('Service', 'Repository') + '.ts';
+              const repoPath = path.join(REPO_DIR, repoName);
+              // 실제 Repository 파일이 존재하는지 확인
+              if (fs.existsSync(repoPath)) {
+                const relativePath = path.relative(NH_DIR, dir);
+                mappings[relativePath.replace(/\\/g, '/')] = repoName;
+                break; // 첫 번째 유효한 Service 사용
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+
+  scanStores(NH_DIR);
+
+  return mappings;
+}
+
+// Pb 접두사 처리
+function handlePbPrefix(folderName, baseName) {
+  // 폴더가 Pb로 시작하면 Repository도 Pb로 시작하는지 확인
+  if (folderName.startsWith('pb') || folderName.startsWith('Pb')) {
+    if (!baseName.startsWith('Pb')) {
+      return `Pb${baseName}`;
+    }
+  }
+  return baseName;
+}
+
+// 메인 실행 함수
+async function main() {
+  console.log('=== MCP Store 생성 시작 ===\n');
+
+  // 기존 StoreNew 파일에서 매핑 생성
+  const mapping = getExistingStoreMapping();
+  console.log(`자동 생성된 매핑: ${Object.keys(mapping).length}개\n`);
+
+  // 일부 매핑 출력 (디버깅)
+  console.log('샘플 매핑:');
+  Object.entries(mapping).slice(0, 5).forEach(([folder, repo]) => {
+    console.log(`  ${folder} → ${repo}`);
+  });
+
+  let successCount = 0;
+  let skipCount = 0;
+  let errorCount = 0;
+
+  for (const [folder, repoFileName] of Object.entries(mapping)) {
+    const repoPath = path.join(REPO_DIR, repoFileName);
+
+    if (!fs.existsSync(repoPath)) {
+      console.log(`[SKIP] ${folder} - Repository 파일 없음: ${repoFileName}`);
+      skipCount++;
+      continue;
+    }
+
+    // Repository 이름에서 baseName 추출
+    const baseName = repoFileName.replace('Repository.ts', '');
+    const outputPath = path.join(NH_DIR, folder, `use${baseName}StoreNew.ts`);
+
+    try {
+      // MCP generate 핸들러 직접 호출
+      const result = await generateStore({
+        interfacePath: repoPath,
+        outputPath: outputPath,
+        storeType: 5, // Simple List
+        storeName: `use${baseName}Store`,
+      });
+
+      const resultData = JSON.parse(result.content[0].text);
+
+      if (resultData.success) {
+        console.log(`[SUCCESS] ${folder} → use${baseName}StoreNew.ts`);
+        successCount++;
+      } else {
+        console.log(`[ERROR] ${folder} - ${resultData.error}`);
+        errorCount++;
+      }
+    } catch (error) {
+      console.log(`[ERROR] ${folder} - ${error.message}`);
+      errorCount++;
+    }
+  }
+
+  console.log(`\n=== 생성 완료 ===`);
+  console.log(`성공: ${successCount}`);
+  console.log(`건너뜀: ${skipCount}`);
+  console.log(`오류: ${errorCount}`);
+}
+
+main().catch(console.error);