i18ntk 1.10.2 → 2.0.2

package/main/i18ntk-analyze.js

@@ -27,7 +27,7 @@ const SetupEnforcer = require('../utils/setup-enforcer');
   }
 })();
 
-loadTranslations( 'en', path.resolve(__dirname, '..', 'ui-locales'));
+loadTranslations( 'en', path.resolve(__dirname, '..', 'resources', 'i18n', 'ui-locales'));
 
 const PROJECT_ROOT = process.cwd();
 
@@ -67,7 +67,7 @@ class I18nAnalyzer {
       this.config = { ...baseConfig, ...(this.config || {}) };
       
       const uiLanguage = (this.config && this.config.uiLanguage) || 'en';
-      loadTranslations(uiLanguage, path.resolve(__dirname, '..', 'ui-locales'));
+      loadTranslations(uiLanguage, path.resolve(__dirname, '..', 'resources', 'i18n', 'ui-locales'));
       
       this.sourceDir = this.config.sourceDir;
       this.sourceLanguageDir = path.join(this.sourceDir, this.config.sourceLanguage);
@@ -884,7 +884,7 @@ try {
         this.config = { ...baseConfig, ...this.config };
         
         const uiLanguage = this.config.uiLanguage || 'en';
-        loadTranslations(uiLanguage, path.resolve(__dirname, '..', 'ui-locales'));
+        loadTranslations(uiLanguage, path.resolve(__dirname, '..', 'resources', 'i18n', 'ui-locales'));
         
         this.sourceDir = this.config.sourceDir;
         this.sourceLanguageDir = path.join(this.sourceDir, this.config.sourceLanguage);
@@ -969,130 +969,110 @@ try {
   }
   
   async runSetupWizard() {
-    console.log('🧙‍♂️  Translation Analysis Setup Wizard');
+    console.log('Translation Analysis Setup Wizard');
     console.log('='.repeat(50));
-    
-    const prompts = require('prompts');
-    
+
     try {
-      // Detect current structure
       const structure = this.detectStructureType();
       console.log(`Current structure detected: ${structure.type}`);
-      
-      const questions = [
-        {
-          type: 'select',
-          name: 'structureType',
-          message: 'Choose your translation file structure:',
-          choices: [
-            { title: 'Monolith files (en.json, de.json, etc.)', value: 'monolith' },
-            { title: 'Directory structure (en/common.json, de/common.json)', value: 'directory' },
-            { title: 'Namespace structure (common/en.json, forms/en.json)', value: 'namespace' },
-            { title: 'Mixed structure (auto-detect)', value: 'mixed' }
-          ],
-          initial: structure.type === 'monolith' ? 0 : structure.type === 'directory' ? 1 : 2
-        },
-        {
-          type: 'text',
-          name: 'sourceDir',
-          message: 'Enter source directory path:',
-          initial: this.sourceDir,
-          validate: value => fs.existsSync(value) ? true : 'Directory does not exist'
-        },
-        {
-          type: 'text',
-          name: 'languages',
-          message: 'Enter languages to analyze (comma-separated, e.g., de,fr,es):',
-          initial: 'de,fr,es,ja,ru',
-          validate: value => value.trim() ? true : 'Please enter at least one language'
-        },
-        {
-          type: 'confirm',
-          name: 'outputReports',
-          message: 'Generate detailed reports for each language?',
-          initial: true
-        },
-        {
-          type: 'text',
-          name: 'outputDir',
-          message: 'Enter output directory for reports:',
-          initial: this.outputDir
-        }
-      ];
-      
-      const response = await prompts(questions);
-      
-      if (!response.structureType) {
-        console.log('Setup cancelled.');
+
+      const structureOptions = ['monolith', 'directory', 'namespace', 'mixed'];
+      const defaultStructureIndex = structureOptions.indexOf(structure.type);
+      const defaultStructureChoice = defaultStructureIndex >= 0 ? String(defaultStructureIndex + 1) : '4';
+
+      console.log('Choose your translation file structure:');
+      console.log('1) Monolith files (en.json, de.json, etc.)');
+      console.log('2) Directory structure (en/common.json, de/common.json)');
+      console.log('3) Namespace structure (common/en.json, forms/en.json)');
+      console.log('4) Mixed structure (auto-detect)');
+      const structureChoiceInput = await this.prompt(`Select option [${defaultStructureChoice}]: `);
+      const structureChoice = structureChoiceInput.trim() || defaultStructureChoice;
+      const structureType = structureOptions[Number(structureChoice) - 1] || 'mixed';
+
+      const sourceDirInput = await this.prompt(`Enter source directory path [${this.sourceDir}]: `);
+      const sourceDir = sourceDirInput.trim() || this.sourceDir;
+      if (!SecurityUtils.safeExistsSync(sourceDir, process.cwd())) {
+        console.log('Setup cancelled: directory does not exist.');
         return { success: false, cancelled: true };
       }
-      
-      // Update configuration
+
+      const languagesInput = await this.prompt('Enter languages to analyze (comma-separated) [de,fr,es,ja,ru]: ');
+      const languagesValue = languagesInput.trim() || 'de,fr,es,ja,ru';
+      const languages = languagesValue.split(',').map(lang => lang.trim()).filter(Boolean);
+      if (languages.length === 0) {
+        console.log('Setup cancelled: no languages provided.');
+        return { success: false, cancelled: true };
+      }
+
+      const outputReportsInput = await this.prompt('Generate detailed reports for each language? (Y/n): ');
+      const outputReports = !['n', 'no'].includes(outputReportsInput.trim().toLowerCase());
+
+      const outputDirInput = await this.prompt(`Enter output directory for reports [${this.outputDir}]: `);
+      const outputDir = outputDirInput.trim() || this.outputDir;
+
+      const response = {
+        structureType,
+        sourceDir,
+        languages: languagesValue,
+        outputReports,
+        outputDir
+      };
+
       this.sourceDir = path.resolve(response.sourceDir);
       this.outputDir = path.resolve(response.outputDir);
       this.outputReports = response.outputReports;
-      
-      const languages = response.languages.split(',').map(lang => lang.trim()).filter(Boolean);
-      
-      console.log('\n📊 Configuration Summary:');
+
+      console.log('\nConfiguration Summary:');
       console.log(`Source: ${this.sourceDir}`);
       console.log(`Output: ${this.outputDir}`);
-      console.log(`Languages: ${languages.join(', ')}`);
+      console.log(`Languages: ${languages.join(", ")}`);
       console.log(`Structure: ${response.structureType}`);
-      
-      const confirm = await prompts({
-        type: 'confirm',
-        name: 'proceed',
-        message: 'Proceed with analysis?',
-        initial: true
-      });
-      
-      if (!confirm.proceed) {
+
+      const proceedInput = await this.prompt('Proceed with analysis? (Y/n): ');
+      const proceed = !['n', 'no'].includes(proceedInput.trim().toLowerCase());
+      if (!proceed) {
         console.log('Setup cancelled.');
         return { success: false, cancelled: true };
       }
-      
-      // Run analysis with specified languages
+
       const results = [];
       for (const language of languages) {
         try {
-          console.log(`\n🔍 Analyzing ${language}...`);
+          console.log(`\nAnalyzing ${language}...`);
           const result = await this.analyzeLanguage(language);
           results.push({ language, ...result });
-          
+
           if (this.outputReports) {
             await this.saveReport(language, result);
-            console.log(`✅ Report saved: ${language}.json`);
+            console.log(`Report saved: ${language}.json`);
           }
         } catch (error) {
-          console.error(`❌ Error analyzing ${language}:`, error.message);
+          console.error(`Error analyzing ${language}:`, error.message);
           results.push({ language, error: error.message });
         }
       }
-      
-      // Generate summary
+
       const summary = {
         totalLanguages: results.length,
         successful: results.filter(r => !r.error).length,
         failed: results.filter(r => r.error).length,
         results
       };
-      
+
       await this.saveReport('wizard-summary', {
         summary,
         configuration: response,
         timestamp: new Date().toISOString()
       });
-      
-      console.log('\n🎉 Setup complete!');
+
+      console.log('\nSetup complete.');
       console.log(`Analyzed ${summary.successful}/${summary.totalLanguages} languages successfully`);
-      
+
       return {
         success: true,
         summary,
         configuration: response
       };
-      
     } catch (error) {
       console.error('Setup wizard error:', error.message);
       return { success: false, error: error.message };
@@ -1168,4 +1148,5 @@ async function analyzeTranslations(datasetPath) {
 module.exports = {
   I18nAnalyzer,
   analyzeTranslations
-};
+};
+

package/main/i18ntk-backup-class.js

@@ -0,0 +1,420 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const fs = require('fs/promises');
+const path = require('path');
+const { existsSync } = require('fs');
+const configManager = require('../utils/config-manager');
+const { logger } = require('../utils/logger');
+const { colors } = require('../utils/logger');
+const SecurityUtils = require('../utils/security');
+
+/**
+ * I18NTK BACKUP CLASS
+ *
+ * Class-based implementation of backup functionality for use with CommandRouter
+ */
+class I18nBackup {
+    constructor(config = {}) {
+        this.config = config;
+        this.backupDir = path.join(process.cwd(), 'i18n-backups');
+        this.maxBackups = config.backup?.maxBackups || 10;
+    }
+
+    /**
+     * Main run method for the backup command
+     */
+    async run(options = {}) {
+        const command = options.command || options._ && options._[0];
+
+        // Show help if no command provided
+        if (!command) {
+            this.showHelp();
+            return { success: true, command: 'help' };
+        }
+
+        try {
+            switch (command) {
+                case 'create':
+                    return await this.handleCreate(options);
+                case 'restore':
+                    return await this.handleRestore(options);
+                case 'list':
+                    return await this.handleList();
+                case 'verify':
+                    return await this.handleVerify(options);
+                case 'cleanup':
+                    return await this.handleCleanup(options);
+                default:
+                    logger.error(`Unknown command: ${command}`);
+                    this.showHelp();
+                    return { success: false, error: `Unknown command: ${command}` };
+            }
+        } catch (error) {
+            this.handleError(error);
+            return { success: false, error: error.message };
+        }
+    }
+
+    showHelp() {
+        console.log(`
+i18ntk-backup - Secure backup and restore for i18n translation files
+
+Usage:
+  i18ntk-backup <command> [options]
+
+Commands:
+  create <dir>     Create a backup of translation files
+  restore <file>   Restore from a backup
+  list             List available backups
+  verify <file>    Verify the integrity of a backup file
+  cleanup          Remove old backups
+
+Options:
+  --output <path>   Output directory for backup/restore
+  --force           Overwrite existing files without prompting
+  --keep <number>   Number of backups to keep (default: 10)
+`);
+    }
+
+    // Command handlers
+    async handleCreate(options = {}) {
+        // Use absolute path for the locales directory
+        const dir = (options._ && options._[1]) || options.dir || path.join(__dirname, '..', 'locales');
+        const outputDir = options.output || this.backupDir;
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupName = `backup-${timestamp}.json`;
+        const backupPath = path.join(outputDir, backupName);
+
+        // Log the paths for debugging
+        logger.debug(`Source directory: ${dir}`);
+        logger.debug(`Backup will be saved to: ${backupPath}`);
+
+        // Create backup directory if it doesn't exist
+        try {
+            await fs.mkdir(outputDir, { recursive: true });
+            logger.debug(`Created backup directory: ${outputDir}`);
+        } catch (err) {
+            if (err.code !== 'EEXIST') {
+                logger.error(`Failed to create backup directory: ${err.message}`);
+                throw err;
+            }
+            logger.debug(`Using existing backup directory: ${outputDir}`);
+        }
+
+        // Validate directory
+        const sourceDir = path.resolve(dir);
+        try {
+            const stats = await fs.stat(sourceDir);
+            if (!stats.isDirectory()) {
+                throw new Error(`Path exists but is not a directory: ${sourceDir}`);
+            }
+            logger.debug(`Source directory exists: ${sourceDir}`);
+        } catch (err) {
+            if (err.code === 'ENOENT') {
+                throw new Error(`Directory not found: ${sourceDir}. Please specify a valid directory.`);
+            }
+            throw new Error(`Error accessing directory ${sourceDir}: ${err.message}`);
+        }
+
+        logger.info('\nCreating backup...');
+
+        // Read all files in the directory
+        const files = (await fs.readdir(sourceDir, { withFileTypes: true }))
+            .filter(dirent => dirent.isFile() && dirent.name.endsWith('.json'))
+            .map(dirent => dirent.name);
+
+        if (files.length === 0) {
+            logger.warn('No JSON files found in the specified directory');
+            return { success: true, message: 'No files to backup' };
+        }
+
+        // Read all translation files
+        const translations = {};
+        for (const file of files) {
+            const filePath = path.join(sourceDir, file);
+            try {
+                const content = JSON.parse(await fs.readFile(filePath, 'utf8'));
+                translations[file] = content;
+            } catch (error) {
+                logger.error(`Could not read file ${file}: ${error.message}`);
+            }
+        }
+
+        // Create the backup
+        await fs.writeFile(backupPath, JSON.stringify(translations, null, 2));
+        const stats = await fs.stat(backupPath);
+
+        logger.success('Backup created successfully');
+        logger.info(`  Location: ${backupPath}`);
+        logger.info(`  Size: ${(stats.size / 1024).toFixed(2)} KB`);
+        logger.info(`  Timestamp: ${new Date().toLocaleString()}`);
+
+        // Clean up old backups
+        await this.cleanupOldBackups(outputDir);
+
+        return {
+            success: true,
+            command: 'create',
+            backupPath,
+            size: stats.size,
+            fileCount: files.length
+        };
+    }
+
+    async handleRestore(options = {}) {
+        const backupFile = options._ && options._[1];
+        if (!backupFile) {
+            throw new Error('Backup file path is required');
+        }
+
+        const backupPath = path.resolve(process.cwd(), backupFile);
+        const outputDir = options.output
+            ? path.resolve(process.cwd(), options.output)
+            : path.join(process.cwd(), 'restored');
+
+        // Validate backup file
+        if (!SecurityUtils.safeExistsSync(backupPath, process.cwd())) {
+            throw new Error(`Backup file not found: ${backupPath}`);
+        }
+
+        logger.info('\nRestoring backup...');
+
+        try {
+            // Read the backup file
+            const backupData = await fs.readFile(backupPath, 'utf8');
+            const translations = JSON.parse(backupData);
+
+            // Create output directory if it doesn't exist
+            try {
+                await fs.mkdir(outputDir, { recursive: true });
+            } catch (err) {
+                if (err.code !== 'EEXIST') throw err;
+            }
+
+            // Write the restored files
+            for (const [file, content] of Object.entries(translations)) {
+                const filePath = path.join(outputDir, file);
+                await fs.writeFile(filePath, JSON.stringify(content, null, 2));
+            }
+
+            logger.success('Backup restored successfully');
+            logger.info(`  Restored ${Object.keys(translations).length} files to: ${outputDir}`);
+
+            return {
+                success: true,
+                command: 'restore',
+                outputDir,
+                fileCount: Object.keys(translations).length
+            };
+        } catch (error) {
+            this.handleError(error);
+            throw error;
+        }
+    }
+
+    async handleList() {
+        try {
+            // Ensure backup directory exists
+            try {
+                await fs.access(this.backupDir);
+            } catch (err) {
+                if (err.code === 'ENOENT') {
+                    logger.warn('No backups found. The backup directory does not exist yet.');
+                } else {
+                    logger.error(`Error accessing backup directory: ${err.message}`);
+                }
+                return { success: true, backups: [] };
+            }
+
+            const files = await fs.readdir(this.backupDir);
+            const backups = [];
+
+            for (const file of files) {
+                if (file.startsWith('backup-') && file.endsWith('.json')) {
+                    try {
+                        const filePath = path.join(this.backupDir, file);
+                        const stats = await fs.stat(filePath);
+                        backups.push({
+                            name: file,
+                            path: filePath,
+                            size: stats.size,
+                            createdAt: stats.mtime
+                        });
+                    } catch (err) {
+                        logger.warn(`Skipping invalid backup file ${file}: ${err.message}`);
+                    }
+                }
+            }
+
+            if (backups.length === 0) {
+                logger.warn('No valid backup files found in the backup directory.');
+                return { success: true, backups: [] };
+            }
+
+            // Sort by creation time (newest first)
+            backups.sort((a, b) => b.createdAt - a.createdAt);
+
+            logger.info('\n📋 Available Backups');
+            logger.info('='.repeat(50));
+
+            backups.forEach((backup, index) => {
+                const sizeKB = (backup.size / 1024).toFixed(2);
+                const formattedDate = backup.createdAt.toLocaleString();
+
+                logger.info(`🔹 ${index + 1}. ${backup.name}`);
+                logger.info(`   📏 Size: ${sizeKB} KB`);
+                logger.info(`   📅 Created: ${formattedDate}`);
+                logger.info(`   📂 Path: ${backup.path}\n`);
+            });
+
+            logger.info(`Total backups: ${backups.length}`);
+
+            return { success: true, backups, count: backups.length };
+        } catch (err) {
+            if (err.code === 'ENOENT') {
+                logger.warn('No backups found.');
+                return { success: true, backups: [] };
+            } else {
+                throw err;
+            }
+        }
+    }
+
+    async handleVerify(options = {}) {
+        const backupFile = options._ && options._[1];
+        if (!backupFile) {
+            throw new Error('Backup file path is required');
+        }
+
+        const backupPath = path.resolve(process.cwd(), backupFile);
+
+        // Validate backup file
+        if (!SecurityUtils.safeExistsSync(backupPath, process.cwd())) {
+            throw new Error(`Backup file not found: ${backupPath}`);
+        }
+
+        logger.info('\nVerifying backup...');
+
+        try {
+            const data = await fs.readFile(backupPath, 'utf8');
+            const content = JSON.parse(data);
+
+            if (typeof content === 'object' && content !== null) {
+                const fileCount = Object.keys(content).length;
+                logger.success('Backup is valid');
+                logger.info(`  Contains ${fileCount} translation files`);
+                logger.info(`  Last modified: ${(await fs.stat(backupPath)).mtime.toLocaleString()}`);
+
+                return {
+                    success: true,
+                    command: 'verify',
+                    valid: true,
+                    fileCount
+                };
+            } else {
+                throw new Error('Invalid backup format');
+            }
+        } catch (error) {
+            logger.error('Backup verification failed!');
+            logger.error(`  Error: ${error.message}`);
+            return {
+                success: false,
+                command: 'verify',
+                valid: false,
+                error: error.message
+            };
+        }
+    }
+
+    async handleCleanup(options = {}) {
+        const keep = options.keep ? parseInt(options.keep, 10) : this.maxBackups;
+
+        logger.info('\nCleaning up old backups...');
+
+        try {
+            const files = await fs.readdir(this.backupDir);
+            const backupFiles = files
+                .filter(file => file.startsWith('backup-') && file.endsWith('.json'))
+                .map(file => ({
+                    name: file,
+                    path: path.join(this.backupDir, file),
+                    time: fs.statSync(path.join(this.backupDir, file)).mtime.getTime()
+                }))
+                .sort((a, b) => b.time - a.time);
+
+            // Keep only the most recent 'keep' files
+            const toDelete = backupFiles.slice(keep);
+
+            if (toDelete.length === 0) {
+                logger.info('No old backups to delete.');
+                return { success: true, deleted: 0 };
+            }
+
+            // Delete old backups
+            for (const file of toDelete) {
+                try {
+                    await fs.unlink(file.path);
+                    logger.info(`  - Deleted: ${file.name}`);
+                } catch (err) {
+                    logger.error(`  - Failed to delete ${file.name}: ${err.message}`);
+                }
+            }
+
+            logger.info(`\nRemoved ${toDelete.length} old backups`);
+            logger.info(`Total backups kept: ${keep}`);
+
+            return {
+                success: true,
+                command: 'cleanup',
+                deleted: toDelete.length,
+                kept: keep
+            };
+        } catch (error) {
+            logger.error('Error cleaning up backups:');
+            logger.error(`  ${error.message}`);
+            if (process.env.DEBUG) {
+                console.error(error);
+            }
+            throw error;
+        }
+    }
+
+    async cleanupOldBackups(outputDir) {
+        try {
+            const files = await fs.readdir(outputDir);
+            const backupFiles = files
+                .filter(file => file.startsWith('backup-') && file.endsWith('.json'))
+                .map(file => ({
+                    name: file,
+                    path: path.join(outputDir, file),
+                    time: fs.statSync(path.join(outputDir, file)).mtime.getTime()
+                }))
+                .sort((a, b) => b.time - a.time);
+
+            // Keep only the most recent files
+            const toDelete = backupFiles.slice(this.maxBackups);
+
+            for (const file of toDelete) {
+                try {
+                    await fs.unlink(file.path);
+                } catch (err) {
+                    // Ignore cleanup errors
+                }
+            }
+        } catch (error) {
+            // Ignore cleanup errors
+        }
+    }
+
+    handleError(error) {
+        logger.error('Backup operation failed:');
+        logger.error(`  ${error.message}`);
+        if (process.env.DEBUG) {
+            console.error(error);
+        }
+    }
+}
+
+module.exports = I18nBackup;

package/main/i18ntk-backup.js

@@ -40,7 +40,7 @@ const { existsSync } = require('fs');
 const configManager = require('../utils/config-manager');
 const { logger } = require('../utils/logger');
 const { colors } = require('../utils/logger');
-const prompt = require('../utils/prompt-fixed');
+const prompt = require('../utils/prompt');
 
 // Backup configuration
 const config = configManager.getConfig();
@@ -195,7 +195,7 @@ async function handleRestore(args) {
     : path.join(process.cwd(), 'restored');
   
   // Validate backup file
-  if (!fs.existsSync(backupPath)) {
+  if (!SecurityUtils.safeExistsSync(backupPath, process.cwd())) {
     throw new Error(`Backup file not found: ${backupPath}`);
   }
   
@@ -300,7 +300,7 @@ async function handleVerify(args) {
   const backupPath = path.resolve(process.cwd(), backupFile);
   
   // Validate backup file
-  if (!fs.existsSync(backupPath)) {
+  if (!SecurityUtils.safeExistsSync(backupPath, process.cwd())) {
     throw new Error(`Backup file not found: ${backupPath}`);
   }