@logistically/i18n-cli/dist/cli.js

Enterprise-grade CLI tool for extracting and managing translations in Logistically microservices

#!/usr/bin/env node
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const commander_1 = require("commander");
const extract_1 = require("./commands/extract");
const generate_1 = require("./commands/generate");
const replace_1 = require("./commands/replace");
const config_1 = require("./commands/config");
const logger_1 = require("./utils/logger");
const config_2 = require("./utils/config");
const performance_1 = require("./utils/performance");
const logger = logger_1.Logger.getInstance();
async function main() {
    // Initialize configuration
    const configManager = config_2.ConfigManager.getInstance();
    const config = await configManager.loadConfig();
    // Configure logger with environment settings
    logger.configure(config.logging);
    // Start performance monitoring
    const performanceMonitor = new performance_1.PerformanceMonitor();
    performanceMonitor.startMonitoring();
    const program = new commander_1.Command();
    program
        .name('i18n')
        .description('Enterprise-grade CLI tool for extracting and managing translations in Logistically microservices')
        .version('2.0.0')
        .option('--config <file>', 'Specify configuration file')
        .option('--log-level <level>', 'Set log level (debug, info, warn, error)', config.logging.level)
        .option('--log-format <format>', 'Set log format (text, json)', config.logging.format)
        .option('--log-output <output>', 'Set log output (console, file, both)', config.logging.output)
        .option('--log-file <file>', 'Set log file path')
        .option('--max-concurrency <number>', 'Set max concurrency', config.performance.maxConcurrency.toString())
        .option('--max-file-size <number>', 'Set max file size in MB', config.performance.maxFileSize.toString())
        .option('--timeout <number>', 'Set timeout in seconds', config.performance.timeout.toString())
        .option('--validate-inputs', 'Enable input validation', config.security.validateInputs)
        .option('--sanitize-outputs', 'Enable output sanitization', config.security.sanitizeOutputs)
        .option('--enable-validation', 'Enable validation features', config.features.enableValidation)
        .option('--enable-backup', 'Enable backup features', config.features.enableBackup)
        .option('--enable-dry-run', 'Enable dry run features', config.features.enableDryRun)
        .option('--enable-progress-bar', 'Enable progress bar', config.features.enableProgressBar)
        .hook('preAction', async (thisCommand) => {
        const options = thisCommand.opts();
        // Update configuration from command line options
        if (options.logLevel)
            config.logging.level = options.logLevel;
        if (options.logFormat)
            config.logging.format = options.logFormat;
        if (options.logOutput)
            config.logging.output = options.logOutput;
        if (options.logFile)
            config.logging.filePath = options.logFile;
        if (options.maxConcurrency)
            config.performance.maxConcurrency = parseInt(options.maxConcurrency);
        if (options.maxFileSize)
            config.performance.maxFileSize = parseInt(options.maxFileSize);
        if (options.timeout)
            config.performance.timeout = parseInt(options.timeout);
        if (options.validateInputs !== undefined)
            config.security.validateInputs = options.validateInputs;
        if (options.sanitizeOutputs !== undefined)
            config.security.sanitizeOutputs = options.sanitizeOutputs;
        if (options.enableValidation !== undefined)
            config.features.enableValidation = options.enableValidation;
        if (options.enableBackup !== undefined)
            config.features.enableBackup = options.enableBackup;
        if (options.enableDryRun !== undefined)
            config.features.enableDryRun = options.enableDryRun;
        if (options.enableProgressBar !== undefined)
            config.features.enableProgressBar = options.enableProgressBar;
        // Reconfigure logger with updated settings
        logger.configure(config.logging);
        // Log startup information
        logger.debug('CLI started', 'main', {
            environment: config.environment,
            version: config.version,
            logLevel: config.logging.level,
            maxConcurrency: config.performance.maxConcurrency
        });
    })
        .hook('postAction', async () => {
        // Log completion and performance metrics
        const metrics = performanceMonitor.endMonitoring();
        logger.debug('CLI completed', 'main', {
            duration: metrics.duration,
            memoryUsage: metrics.memoryUsage
        });
    })
        .addCommand((0, extract_1.createExtractCommand)())
        .addCommand((0, generate_1.createGenerateCommand)())
        .addCommand((0, replace_1.createReplaceCommand)())
        .addCommand((0, config_1.createConfigCommand)())
        .addHelpText('after', `

Enterprise Features:
  • Configuration Management: translation config show/validate/set/reset
  • Performance Monitoring: Built-in metrics and progress tracking
  • Security Validation: Input/output sanitization and validation
  • Concurrent Processing: Parallel file processing with configurable limits
  • Advanced Logging: JSON/text formats, file/console output
  • Progress Tracking: Real-time progress bars and ETA
  • Error Handling: Comprehensive error reporting and recovery

Examples:
  $ i18n extract                    # Extract from current directory
  $ i18n extract -p ./src          # Extract from specific path
  $ i18n extract -o my-keys.json   # Save to custom file
  $ i18n extract -v                # Verbose output
  
  $ i18n generate                  # Generate from translation-keys.json
  $ i18n generate -i my-keys.json # Use custom input file
  $ i18n generate -l en,fr,es     # Generate specific languages
  $ i18n generate --no-template   # Skip template files
  
  $ i18n replace                   # Replace strings with translation keys
  $ i18n replace --dry-run        # Show what would be replaced
  $ i18n replace --no-backup      # Skip backup files
  
  $ i18n config show              # Show current configuration
  $ i18n config validate          # Validate configuration
  $ i18n config set logging.level debug  # Set config value
  $ i18n config reset             # Reset to defaults

Environment Variables:
  NODE_ENV              Environment (development/staging/production)
  LOG_LEVEL             Log level (debug/info/warn/error)
  MAX_CONCURRENCY       Max concurrent file processing
  MAX_FILE_SIZE         Max file size in MB
  TIMEOUT               Operation timeout in seconds
  VALIDATE_INPUTS       Enable input validation (true/false)
  SANITIZE_OUTPUTS      Enable output sanitization (true/false)

Workflow:
  1. Configure the CLI: i18n config show
  2. Extract translatable strings: i18n extract
  3. Generate translation files: i18n generate
  4. Replace hardcoded strings: i18n replace
  5. Translate the generated files manually
  6. Use @logistically/i18n library in your services

For more information, visit: https://github.com/logistically/i18n-cli
    `);
    try {
        await program.parseAsync();
    }
    catch (error) {
        logger.error(`CLI error: ${error instanceof Error ? error.message : 'Unknown error'}`, 'main');
        process.exit(1);
    }
}
main();
//# sourceMappingURL=cli.js.map