kira-crud/config-standardize.js

Intelligent CRUD Generator for Laravel and Angular

#!/usr/bin/env node

/**
 * Configuration Standardization CLI
 * Converts all configuration files to a standard format (YAML or JSON)
 */

const { program } = require('commander');
const chalk = require('chalk');
const ora = require('ora');
const path = require('path');
const fs = require('fs').promises;
const { standardizeConfigFiles, convertConfigFormat } = require('./utils/config-converter');

// Configure CLI
program
  .name('config-standardize')
  .description('Standardize configuration files to a consistent format')
  .version('1.0.0')
  .option('-d, --dir <directory>', 'Directory containing configuration files', './examples')
  .option('-f, --format <format>', 'Target format (yaml or json)', 'yaml')
  .option('-r, --recursive', 'Process subdirectories recursively', false)
  .option('-s, --single <file>', 'Convert a single file instead of a directory')
  .option('-o, --output <file>', 'Output file for single file conversion (optional)')
  .option('-v, --verbose', 'Display detailed information', false)
  .parse(process.argv);

const options = program.opts();

/**
 * Main application
 */
async function main() {
  try {
    // Validate options
    if (options.format && !['yaml', 'yml', 'json'].includes(options.format.toLowerCase())) {
      console.error(chalk.red(`Error: Invalid format "${options.format}". Must be yaml, yml, or json.`));
      process.exit(1);
    }
    
    // Standardize format
    const format = options.format.toLowerCase();
    
    if (options.single) {
      // Convert a single file
      await convertSingleFile(options.single, format, options.output);
    } else {
      // Convert all files in directory
      await convertDirectory(options.dir, format, options.recursive);
    }
  } catch (error) {
    console.error(chalk.red(`\nError: ${error.message}`));
    process.exit(1);
  }
}

/**
 * Convert a single file
 * @param {string} inputPath - Path to input file
 * @param {string} format - Target format
 * @param {string} outputPath - Path to output file (optional)
 */
async function convertSingleFile(inputPath, format, outputPath) {
  const spinner = ora(`Converting ${inputPath} to ${format.toUpperCase()}...`).start();
  
  try {
    // Resolve paths
    const resolvedInputPath = path.resolve(inputPath);
    
    // Check if input file exists
    try {
      await fs.access(resolvedInputPath);
    } catch (error) {
      spinner.fail(`Input file not found: ${resolvedInputPath}`);
      return;
    }
    
    // Convert file
    const result = await convertConfigFormat(resolvedInputPath, format, outputPath);
    
    spinner.succeed(`Converted to ${format.toUpperCase()}: ${result}`);
  } catch (error) {
    spinner.fail(`Conversion failed: ${error.message}`);
  }
}

/**
 * Convert all configuration files in a directory
 * @param {string} directory - Directory to process
 * @param {string} format - Target format
 * @param {boolean} recursive - Whether to process subdirectories
 */
async function convertDirectory(directory, format, recursive) {
  const resolvedDir = path.resolve(directory);
  const spinner = ora(`Standardizing configuration files in ${resolvedDir} to ${format.toUpperCase()}...`).start();
  
  try {
    // Check if directory exists
    try {
      const stats = await fs.stat(resolvedDir);
      if (!stats.isDirectory()) {
        spinner.fail(`Not a directory: ${resolvedDir}`);
        return;
      }
    } catch (error) {
      spinner.fail(`Directory not found: ${resolvedDir}`);
      return;
    }
    
    // Standardize files
    const stats = await standardizeConfigFiles(resolvedDir, format, recursive);
    
    if (stats.errors.length > 0) {
      spinner.warn(`Processed ${stats.processed} files: ${stats.converted} converted, ${stats.skipped} skipped, ${stats.errors.length} errors`);
      
      // Display errors
      console.log(chalk.yellow('\nErrors:'));
      stats.errors.forEach(error => {
        console.log(chalk.yellow(`- ${error.file}: ${error.error}`));
      });
    } else {
      spinner.succeed(`Processed ${stats.processed} files: ${stats.converted} converted, ${stats.skipped} skipped`);
    }
    
    // Detailed information if verbose
    if (options.verbose && stats.converted > 0) {
      console.log(chalk.blue('\nConverted files:'));
      
      // List converted files (would need to return this info from standardizeConfigFiles)
      // for now, just a placeholder
      console.log(chalk.blue(`- ${stats.converted} files converted to ${format.toUpperCase()}`));
    }
  } catch (error) {
    spinner.fail(`Standardization failed: ${error.message}`);
  }
}

// Run the main function
if (require.main === module) {
  main();
}

module.exports = {
  convertSingleFile,
  convertDirectory
};