@axboot-mcp/mcp-server 1.0.0

package/scripts/batch-generate-stores-v2.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+
+/**
+ * Batch Store Generator v2 - Using MCP Server Direct Integration
+ *
+ * This script processes Repository interface files and generates Zustand stores
+ * using the mcp-axboot MCP server's analyze_interface and generate_store tools.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 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 RESULTS_FILE = path.join(OUTPUT_DIR, 'generation-results.md');
+const BATCH_SIZE = 10; // Process in batches
+
+// Store type mapping based on feature analysis
+const STORE_TYPE_MAPPING = {
+  // Type 7: Master-Detail + Modal + Delete + Excel (most complete)
+  'list-detail-save-delete-export': 7,
+  // Type 2: Master-Detail + Modal + Delete
+  'list-detail-save-delete': 2,
+  // Type 9: Master-Detail + Modal + Detail API
+  'list-detail-save-export': 9,
+  // Type 1: Basic List + Detail
+  'list-save-delete': 1,
+  'list-save': 1,
+  'list-detail-save': 1,
+  // Type 5: Simple List (default)
+  'default': 5
+};
+
+/**
+ * Analyze repository file to determine best store type
+ */
+function analyzeRepository(filePath, repoName) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+
+  const features = {
+    list: /\b(list|find|search)\b/i.test(content),
+    detail: /\b(detail|dtlinfo|get)\b/i.test(content),
+    save: /\b(save|update|insert|create|modify|regist)\b/i.test(content),
+    delete: /\b(delete|remove)\b/i.test(content),
+    excel: /\b(excel|export|download)\b/i.test(content)
+  };
+
+  // Determine store type
+  const featureKey = Object.entries(features)
+    .filter(([k, v]) => v)
+    .map(([k]) => k)
+    .sort()
+    .join('-');
+
+  const storeType = STORE_TYPE_MAPPING[featureKey] || STORE_TYPE_MAPPING['default'];
+
+  return {
+    features,
+    storeType,
+    featureKey
+  };
+}
+
+/**
+ * Get store name from repository name
+ */
+function getStoreName(repoName) {
+  const baseName = repoName.replace('Repository', '');
+  return `use${baseName}ListStore`;
+}
+
+/**
+ * Get output file path from repository name
+ */
+function getOutputPath(repoName) {
+  const storeName = getStoreName(repoName);
+  return path.join(OUTPUT_DIR, `${storeName}.ts`);
+}
+
+/**
+ * Process batch of repositories
+ */
+function processBatch(repos, batchNum) {
+  console.log(`\n${'='.repeat(80)}`);
+  console.log(`Processing Batch ${batchNum} (${repos.length} files)`);
+  console.log(`${'='.repeat(80)}\n`);
+
+  return repos.map((repoName, idx) => {
+    const filePath = path.join(REPO_DIR, `${repoName}.ts`);
+    const outputPath = getOutputPath(repoName);
+    const storeName = getStoreName(repoName);
+
+    try {
+      const { features, storeType, featureKey } = analyzeRepository(filePath, repoName);
+
+      console.log(`${idx + 1}. ${repoName}`);
+      console.log(`   Type: ${storeType} | Features: ${featureKey}`);
+      console.log(`   Store: ${storeName}`);
+      console.log(`   Output: ${outputPath}`);
+
+      return {
+        repository: repoName,
+        storeName,
+        storeType,
+        features,
+        featureKey,
+        outputPath,
+        inputPath: filePath,
+        status: 'analyzed'
+      };
+    } catch (error) {
+      console.error(`${idx + 1}. ${repoName} - ERROR: ${error.message}`);
+      return {
+        repository: repoName,
+        status: 'failed',
+        error: error.message
+      };
+    }
+  });
+}
+
+/**
+ * Generate markdown report
+ */
+function generateReport(allResults) {
+  const successful = allResults.filter(r => r.status === 'analyzed');
+  const failed = allResults.filter(r => r.status === 'failed');
+
+  // Type distribution
+  const typeDist = {};
+  successful.forEach(r => {
+    typeDist[r.storeType] = (typeDist[r.storeType] || 0) + 1;
+  });
+
+  const lines = [];
+
+  lines.push('# Store Generation Results');
+  lines.push('');
+  lines.push(`**Generated:** ${new Date().toLocaleString('ko-KR')}`);
+  lines.push(`**Source Directory:** \`${REPO_DIR}\``);
+  lines.push(`**Output Directory:** \`${OUTPUT_DIR}\``);
+  lines.push('');
+
+  // Summary
+  lines.push('## Summary');
+  lines.push('');
+  lines.push('| Metric | Count |');
+  lines.push('|--------|-------|');
+  lines.push(`| Total Repositories | ${allResults.length} |`);
+  lines.push(`| ✅ Successfully Analyzed | ${successful.length} |`);
+  lines.push(`| ❌ Failed | ${failed.length} |`);
+  lines.push('');
+
+  // Store type distribution
+  lines.push('## Store Type Distribution');
+  lines.push('');
+  lines.push('| Type | Description | Count |');
+  lines.push('|------|-------------|-------|');
+  lines.push('| 1 | Basic List + Detail | ' + (typeDist[1] || 0) + ' |');
+  lines.push('| 2 | Master-Detail + Modal + Delete | ' + (typeDist[2] || 0) + ' |');
+  lines.push('| 5 | Simple List | ' + (typeDist[5] || 0) + ' |');
+  lines.push('| 7 | Master-Detail + Modal + Delete + Excel | ' + (typeDist[7] || 0) + ' |');
+  lines.push('| 9 | Master-Detail + Modal + Detail API | ' + (typeDist[9] || 0) + ' |');
+  lines.push('');
+
+  // Store Type Reference
+  lines.push('## Store Type Reference');
+  lines.push('');
+  lines.push('| Type | Template File | Pattern |');
+  lines.push('|------|---------------|---------|');
+  lines.push('| 1 | type1.ts | Basic List + Detail |');
+  lines.push('| 2 | type2.ts | Master-Detail + Modal + Delete |');
+  lines.push('| 5 | type6.ts | Simple List |');
+  lines.push('| 7 | type8.ts | Master-Detail + Modal + Delete + Excel |');
+  lines.push('| 9 | type10.ts | Master-Detail + Modal + Detail API |');
+  lines.push('');
+
+  // Detailed results
+  lines.push('## Detailed Results');
+  lines.push('');
+  lines.push('| # | Repository | Store Name | Type | Features | Input Path | Output Path |');
+  lines.push('|---|------------|------------|------|----------|------------|-------------|');
+
+  successful.forEach((r, i) => {
+    const featureStr = Object.entries(r.features)
+      .filter(([k, v]) => v)
+      .map(([k]) => k)
+      .join(', ') || '-';
+    lines.push(`| ${i + 1} | \`${r.repository}\` | \`${r.storeName}\` | ${r.storeType} | ${featureStr} | \`${r.inputPath}\` | \`${r.outputPath}\` |`);
+  });
+  lines.push('');
+
+  // Failed items
+  if (failed.length > 0) {
+    lines.push('## Failed Items');
+    lines.push('');
+    failed.forEach((r, i) => {
+      lines.push(`${i + 1}. **${r.repository}** - ${r.error}`);
+    });
+    lines.push('');
+  }
+
+  // Generate commands for manual MCP usage
+  lines.push('## MCP Usage Examples');
+  lines.push('');
+  lines.push('To generate stores using the MCP server, use these commands:');
+  lines.push('');
+  lines.push('```typescript');
+  lines.push('// For a simple list store (Type 5)');
+  lines.push('await generateStore({');
+  lines.push('  interfacePath: "/absolute/path/to/Repository.ts",');
+  lines.push('  outputPath: "/absolute/path/to/useStoreName.ts",');
+  lines.push('  storeType: 5');
+  lines.push('});');
+  lines.push('```');
+  lines.push('');
+
+  fs.writeFileSync(RESULTS_FILE, lines.join('\n'), 'utf-8');
+  return RESULTS_FILE;
+}
+
+/**
+ * Main execution
+ */
+function main() {
+  console.log('\n' + '='.repeat(80));
+  console.log('  Batch Store Generator for mcp-axboot');
+  console.log('='.repeat(80));
+
+  // Ensure output directory exists
+  if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+  }
+
+  // Get all repository files
+  const files = fs.readdirSync(REPO_DIR)
+    .filter(f => f.endsWith('Repository.ts'))
+    .map(f => f.replace('.ts', ''))
+    .sort();
+
+  console.log(`\n📁 Found ${files.length} repository files`);
+  console.log(`📂 Output directory: ${OUTPUT_DIR}`);
+
+  const allResults = [];
+  let batchNum = 1;
+
+  // Process in batches
+  for (let i = 0; i < files.length; i += BATCH_SIZE) {
+    const batch = files.slice(i, i + BATCH_SIZE);
+    const batchResults = processBatch(batch, batchNum++);
+    allResults.push(...batchResults);
+  }
+
+  // Generate report
+  console.log('\n' + '='.repeat(80));
+  console.log('  Generating Report...');
+  console.log('='.repeat(80));
+
+  const reportPath = generateReport(allResults);
+
+  console.log('\n' + '='.repeat(80));
+  console.log('  Summary');
+  console.log('='.repeat(80));
+  console.log(`Total: ${allResults.length}`);
+  console.log(`✅ Analyzed: ${allResults.filter(r => r.status === 'analyzed').length}`);
+  console.log(`❌ Failed: ${allResults.filter(r => r.status === 'failed').length}`);
+  console.log(`\n📄 Report saved to: ${reportPath}`);
+}
+
+// Run
+main();

package/scripts/batch-generate-stores.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+
+/**
+ * Batch Store Generator for MCP-AXBOOT
+ *
+ * This script processes all Repository interface files and generates Zustand stores
+ * using the mcp-axboot MCP server tools via the Skill tool.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Configuration
+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 BATCH_SIZE = 20;
+
+/**
+ * Extract repository name from file path
+ */
+function extractRepositoryName(filePath) {
+  const fileName = path.basename(filePath, '.ts');
+  return fileName.replace(/Repository$/, '');
+}
+
+/**
+ * Generate store name from repository name
+ */
+function generateStoreName(repositoryName) {
+  return `use${repositoryName}ListStore`;
+}
+
+/**
+ * Detect store type based on method patterns in the repository file
+ */
+function detectStoreType(filePath) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+
+  const hasList = /\b(list|find|search)\b/i.test(content);
+  const hasDetail = /\b(detail|dtl|info|get)\b/i.test(content);
+  const hasSave = /\b(save|update|insert|create|upt|modify)\b/i.test(content);
+  const hasDelete = /\b(delete|remove|delt|secsn)\b/i.test(content);
+  const hasExcel = /\b(excel|export|download)\b/i.test(content);
+
+  // Type 7: list + detail + save + delete + excel (Master-Detail + Modal + Delete + Excel)
+  if (hasList && hasDetail && hasSave && hasDelete && hasExcel) {
+    return 7;
+  }
+  // Type 2: list + detail + save + delete (Master-Detail + Modal + Delete)
+  if (hasList && hasDetail && hasSave && hasDelete) {
+    return 2;
+  }
+  // Type 1: list + save (Basic List + Detail)
+  if (hasList && hasSave) {
+    return 1;
+  }
+  // Type 5: simple list (default)
+  return 5;
+}
+
+/**
+ * Get all repository files
+ */
+function getRepositoryFiles() {
+  const files = fs.readdirSync(SOURCE_DIR)
+    .filter(file => file.endsWith('Repository.ts'))
+    .map(file => path.join(SOURCE_DIR, file));
+
+  return files.sort();
+}
+
+/**
+ * Process all repository files and create batch plan
+ */
+function main() {
+  console.log('='.repeat(80));
+  console.log('BATCH STORE GENERATION FOR MCP-AXBOOT');
+  console.log('='.repeat(80));
+  console.log(`Source Directory: ${SOURCE_DIR}`);
+  console.log(`Output Directory: ${OUTPUT_DIR}`);
+  console.log(`Batch Size: ${BATCH_SIZE}`);
+  console.log('='.repeat(80));
+  console.log();
+
+  const repositoryFiles = getRepositoryFiles();
+  console.log(`Found ${repositoryFiles.length} repository files\n`);
+
+  // Process all files
+  const results = repositoryFiles.map(filePath => {
+    const repositoryName = extractRepositoryName(filePath);
+    const storeName = generateStoreName(repositoryName);
+    const outputPath = path.join(OUTPUT_DIR, `${storeName}.ts`);
+    const storeType = detectStoreType(filePath);
+
+    return {
+      repositoryName,
+      storeName,
+      inputPath: filePath,
+      outputPath,
+      storeType
+    };
+  });
+
+  // Group by store type for summary
+  const typeGroups = {};
+  results.forEach(r => {
+    const typeName = `Type ${r.storeType}`;
+    if (!typeGroups[typeName]) {
+      typeGroups[typeName] = [];
+    }
+    typeGroups[typeName].push(r);
+  });
+
+  console.log('STORE TYPE DISTRIBUTION:');
+  console.log('-'.repeat(80));
+  Object.keys(typeGroups).sort().forEach(type => {
+    const count = typeGroups[type].length;
+    const pct = ((count / results.length) * 100).toFixed(1);
+    console.log(`  ${type}: ${count} repositories (${pct}%)`);
+  });
+  console.log('-'.repeat(80));
+  console.log();
+
+  // Create output directory if it doesn't exist
+  if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+  }
+
+  // Save the processing plan to JSON for batch processing
+  const planPath = path.join(__dirname, 'batch-plan.json');
+  fs.writeFileSync(planPath, JSON.stringify({
+    generated: new Date().toISOString(),
+    total: results.length,
+    batchSize: BATCH_SIZE,
+    batches: Math.ceil(results.length / BATCH_SIZE),
+    typeDistribution: typeGroups,
+    repositories: results
+  }, null, 2));
+
+  console.log(`✓ Processing plan saved to: ${planPath}`);
+  console.log(`✓ Total repositories to process: ${results.length}`);
+  console.log(`✓ Number of batches: ${Math.ceil(results.length / BATCH_SIZE)}`);
+  console.log();
+
+  // Generate a batch file for execution
+  const batchScript = generateBatchScript(results);
+  const batchScriptPath = path.join(__dirname, 'execute-batches.js');
+  fs.writeFileSync(batchScriptPath, batchScript);
+  console.log(`✓ Batch execution script saved to: ${batchScriptPath}`);
+  console.log();
+
+  console.log('NEXT STEPS:');
+  console.log('1. Review the batch-plan.json file');
+  console.log('2. Run batches using the MCP tool: node scripts/execute-batches.js');
+  console.log();
+}
+
+/**
+ * Generate batch execution script
+ */
+function generateBatchScript(results) {
+  return `#!/usr/bin/env node
+
+/**
+ * Auto-generated batch execution script
+ * Generated: ${new Date().toISOString()}
+ */
+
+const plan = ${JSON.stringify(results, null, 2)};
+
+console.log(\`Processing \${plan.length} repositories...\`);
+
+// Export for use by other scripts
+module.exports = { plan };
+`;
+}
+
+// Run the script
+main().catch(console.error);