@axboot-mcp/mcp-server 1.0.0

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@axboot-mcp/mcp-server",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.0.0",
+  "description": "Axboot MCP Server - Store 생성 및 다른 기능 확장 가능",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc && npm run copy-assets",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "clean": "rm -rf dist",
+    "copy-assets": "npm run copy-docs && npm run copy-prompts",
+    "copy-docs": "mkdir -p dist/docs && cp -r src/docs/*.json src/docs/*.md dist/docs/ 2>/dev/null || true",
+    "copy-prompts": "mkdir -p dist/prompts && cp -r src/prompts/*.md dist/prompts/ 2>/dev/null || true"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "axboot",
+    "zustand",
+    "store",
+    "generator"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "chokidar": "^5.0.0",
+    "glob": "^13.0.0",
+    "mustache": "^4.2.0",
+    "typescript": "^5.7.3"
+  },
+  "devDependencies": {
+    "@types/chokidar": "^1.7.5",
+    "@types/mustache": "^4.2.6",
+    "@types/node": "^22.10.5",
+    "@typescript-eslint/typescript-estree": "^8.53.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/scripts/batch-generate-all.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+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';
+const MCP_SERVER_PATH = '/Users/kyle/work/mcp-axboot/dist/index.js';
+
+// Store type detection patterns
+const PATTERNS = {
+  TYPE_7: { name: 'Type 7', patterns: [/list/i, /detail|dtl/i, /save/i, /delete|del/i], description: 'Master-Detail + Modal + Delete + Excel' },
+  TYPE_2: { name: 'Type 2', patterns: [/list/i, /detail|dtl/i, /save/i, /delete|del/i], description: 'Master-Detail + Modal + Delete' },
+  TYPE_1: { name: 'Type 1', patterns: [/list/i, /save/i], description: 'Basic List + Detail' },
+  TYPE_5: { name: 'Type 5', patterns: [], description: 'Simple List (default)' }
+};
+
+// 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));
+}
+
+// Parse repository file to detect store type
+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());
+
+  // Check for Type 7 (has list + detail + save + delete + excel)
+  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'));
+
+  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; // Default to Type 5 (simple list)
+  }
+}
+
+// Extract repository name from file path
+function getRepositoryName(filePath) {
+  const fileName = path.basename(filePath, 'Repository.ts');
+  return fileName;
+}
+
+// Generate store name from repository name
+function getStoreName(repositoryName) {
+  return `use${repositoryName}ListStore`;
+}
+
+// Get output path for store file
+function getOutputPath(repositoryName) {
+  return path.join(OUTPUT_DIR, `use${repositoryName}ListStore.ts`);
+}
+
+// Call MCP tool to generate store
+function generateStore(interfacePath, outputPath, storeName, storeType) {
+  // This would call the mcp__axboot__generate_store tool
+  // For now, we'll track what needs to be generated
+  return {
+    interfacePath,
+    outputPath,
+    storeName,
+    storeType,
+    status: 'pending'
+  };
+}
+
+// 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,
+    generated: [],
+    failedFiles: []
+  };
+
+  // Process each file
+  for (let i = 0; i < files.length; i++) {
+    const filePath = files[i];
+    const repositoryName = getRepositoryName(filePath);
+    const storeName = getStoreName(repositoryName);
+    const outputPath = getOutputPath(repositoryName);
+    const storeType = detectStoreType(filePath);
+
+    console.log(`[${i + 1}/${files.length}] Processing: ${repositoryName}Repository`);
+    console.log(`  → Store: ${storeName}`);
+    console.log(`  → Type: ${storeType}`);
+    console.log(`  → Output: ${outputPath}`);
+
+    try {
+      // Check if file already exists
+      if (fs.existsSync(outputPath)) {
+        console.log(`  ⚠️  File already exists, skipping...\n`);
+        results.generated.push({ repositoryName, storeName, storeType, status: 'exists' });
+        continue;
+      }
+
+      // TODO: Call the actual MCP tool here
+      // For now, just track it
+      results.generated.push({
+        repositoryName,
+        storeName,
+        storeType,
+        interfacePath: filePath,
+        outputPath,
+        status: 'queued'
+      });
+
+      results.success++;
+      console.log(`  ✓ Queued for generation\n`);
+
+    } catch (error) {
+      results.failed++;
+      results.failedFiles.push({
+        repositoryName,
+        error: error.message
+      });
+      console.log(`  ✗ Error: ${error.message}\n`);
+    }
+  }
+
+  // Print summary
+  console.log('='.repeat(80));
+  console.log('SUMMARY');
+  console.log('='.repeat(80));
+  console.log(`Total files processed: ${results.total}`);
+  console.log(`Successfully queued: ${results.success}`);
+  console.log(`Failed: ${results.failed}`);
+  console.log('');
+
+  // Save detailed results
+  const resultsPath = path.join(OUTPUT_DIR, 'generation-plan.json');
+  fs.writeFileSync(resultsPath, JSON.stringify(results, null, 2));
+  console.log(`Detailed plan saved to: ${resultsPath}`);
+}
+
+main().catch(console.error);

package/scripts/batch-generate-mcp.js

@@ -0,0 +1,329 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+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';
+const MCP_SERVER_PATH = '/Users/kyle/work/mcp-axboot/dist/index.js';
+
+// 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`);
+}
+
+// Call MCP server using the analyze interface first, then generate
+async function analyzeInterface(interfacePath) {
+  return new Promise((resolve, reject) => {
+    const mcp = spawn('node', [MCP_SERVER_PATH], {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    const request = {
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'tools/call',
+      params: {
+        name: 'mcp__axboot__analyze_interface',
+        arguments: {
+          interfacePath
+        }
+      }
+    };
+
+    let stdout = '';
+    let stderr = '';
+
+    mcp.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    mcp.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    mcp.stdin.write(JSON.stringify(request) + '\n');
+
+    setTimeout(() => {
+      mcp.kill();
+      try {
+        const responses = stdout.trim().split('\n').map(line => {
+          try {
+            return JSON.parse(line);
+          } catch {
+            return null;
+          }
+        }).filter(Boolean);
+
+        const response = responses.find(r => r.id === 1);
+        if (response && response.result) {
+          resolve(response.result);
+        } else {
+          reject(new Error('No valid response from MCP server'));
+        }
+      } catch (error) {
+        reject(error);
+      }
+    }, 5000);
+  });
+}
+
+// Generate store using MCP
+async function callGenerateStore(interfacePath, outputPath, storeType, storeName) {
+  return new Promise((resolve, reject) => {
+    const mcp = spawn('node', [MCP_SERVER_PATH], {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    const request = {
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'tools/call',
+      params: {
+        name: 'mcp__axboot__generate_store',
+        arguments: {
+          interfacePath,
+          outputPath,
+          storeType,
+          storeName
+        }
+      }
+    };
+
+    let stdout = '';
+    let stderr = '';
+
+    mcp.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    mcp.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    mcp.stdin.write(JSON.stringify(request) + '\n');
+
+    setTimeout(() => {
+      mcp.kill();
+      try {
+        const responses = stdout.trim().split('\n').map(line => {
+          try {
+            return JSON.parse(line);
+          } catch {
+            return null;
+          }
+        }).filter(Boolean);
+
+        const response = responses.find(r => r.id === 1);
+        if (response) {
+          resolve(response);
+        } else {
+          reject(new Error('No valid response from MCP server'));
+        }
+      } catch (error) {
+        reject(error);
+      }
+    }, 8000);
+  });
+}
+
+// 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 to avoid overwhelming
+  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 MCP tool
+        console.log(`  🔄 Generating store...`);
+        const result = await callGenerateStore(filePath, outputPath, storeType, storeName);
+
+        if (result.error) {
+          throw new Error(result.error.message || '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 to avoid overwhelming
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+  }
+
+  // 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);