i18ntk 1.0.0

package/main/ui-i18n.js

@@ -0,0 +1,332 @@
+/**
+ * UI Internationalization Module
+ * Handles loading and managing UI translations for the i18n management tool
+ */
+
+const fs = require('fs');
+const path = require('path');
+const settingsManager = require('../settings/settings-manager');
+
+// Get configuration from settings manager
+function getConfig() {
+  const settings = settingsManager.getSettings();
+  return {
+    uiLocalesDir: settings.directories?.uiLocalesDir || path.join(__dirname, '..', 'ui-locales'),
+    configFile: settings.directories?.configFile || path.join(__dirname, '..', 'settings', 'user-config.json')
+  };
+}
+
+class UIi18n {
+    constructor() {
+        const config = getConfig();
+        this.currentLanguage = 'en';
+        this.translations = {};
+        this.availableLanguages = ['en', 'de', 'es', 'fr', 'ru', 'ja', 'zh'];
+        this.uiLocalesDir = path.resolve(config.uiLocalesDir);
+        this.configFile = path.resolve(config.configFile);
+
+        // Use settings manager as the single source of truth
+        const settings = settingsManager.getSettings();
+        const configuredLanguage = settings.language;
+
+        // Load language from settings manager or fallback
+        if (configuredLanguage && this.availableLanguages.includes(configuredLanguage)) {
+            this.loadLanguage(configuredLanguage);
+        } else {
+            this.loadLanguage('en');
+        }
+    }
+
+    /**
+     * Load translations for a specific language
+     * @param {string} language - Language code (e.g., 'en', 'de', 'es')
+     */
+    loadLanguage(language) {
+        if (!this.availableLanguages.includes(language)) {
+            console.warn(`⚠️  Language '${language}' not available. Using English as fallback.`);
+            language = 'en';
+        }
+
+        const translationFile = path.join(this.uiLocalesDir, `${language}.json`);
+        
+        try {
+            if (fs.existsSync(translationFile)) {
+                const content = fs.readFileSync(translationFile, 'utf8');
+                this.translations = JSON.parse(content);
+                this.currentLanguage = language;
+            } else {
+                console.warn(`⚠️  Translation file not found: ${translationFile}`);
+                if (language !== 'en') {
+                    this.loadLanguage('en'); // Fallback to English
+                }
+            }
+        } catch (error) {
+            console.error(`❌ Error loading translation file for '${language}':`, error.message);
+            if (language !== 'en') {
+                this.loadLanguage('en'); // Fallback to English
+            }
+        }
+    }
+
+    /**
+     * Load user config from file or return default
+     */
+    loadUserConfig() {
+        try {
+            if (fs.existsSync(this.configFile)) {
+                const content = fs.readFileSync(this.configFile, 'utf8');
+                return JSON.parse(content);
+            }
+        } catch (error) {
+            console.error(`❌ Error loading user config:`, error.message);
+        }
+        return { language: null, sizeLimit: null };
+    }
+
+    /**
+     * Save user config to file
+     */
+    saveUserConfig() {
+        try {
+            fs.writeFileSync(this.configFile, JSON.stringify(this.userConfig, null, 2), 'utf8');
+        } catch (error) {
+            console.error(`❌ Error saving user config:`, error.message);
+        }
+    }
+
+    /**
+     * Run language selector on first run or when forced
+     * @returns {Promise<string>} Selected language code
+     */
+    async initializeLanguage() {
+        if (!this.userConfig.language) {
+            const selectedLang = await this.selectLanguage();
+            this.userConfig.language = selectedLang;
+            this.saveUserConfig();
+            this.changeLanguage(selectedLang);
+            return selectedLang;
+        } else {
+            this.changeLanguage(this.userConfig.language);
+            return this.userConfig.language;
+        }
+    }
+
+    /**
+     * Get translated text by key path
+     * @param {string} keyPath - Dot-separated key path (e.g., 'menu.title')
+     * @param {object} replacements - Object with replacement values
+     * @returns {string|array|object} Translated text or data
+     */
+    t(keyPath, replacements = {}) {
+        const keys = keyPath.split('.');
+        let value = this.translations;
+
+        for (const key of keys) {
+            if (value && typeof value === 'object' && key in value) {
+                value = value[key];
+            } else {
+                // Try to get English fallback if current language is not English
+                if (this.currentLanguage !== 'en') {
+                    const englishFallback = this.getEnglishFallback(keyPath, replacements);
+                    if (englishFallback) {
+                        return englishFallback;
+                    }
+                }
+                console.warn(`⚠️  Translation key not found: ${keyPath}`);
+                return keyPath; // Return the key path as fallback
+            }
+        }
+
+        // Handle different data types
+        if (typeof value === 'string') {
+            // Check if the value is [NOT TRANSLATED] and provide English fallback
+            if (value === '[NOT TRANSLATED]' && this.currentLanguage !== 'en') {
+                const englishFallback = this.getEnglishFallback(keyPath, replacements);
+                if (englishFallback) {
+                    return `${englishFallback} [NOT TRANSLATED]`;
+                }
+                return `[NOT TRANSLATED: ${keyPath}]`;
+            }
+            
+            // Replace placeholders in strings
+            let result = value;
+            for (const [placeholder, replacement] of Object.entries(replacements)) {
+                result = result.replace(new RegExp(`\\{${placeholder}\\}`, 'g'), replacement);
+            }
+            return result;
+        } else if (Array.isArray(value)) {
+            // Return arrays as-is (for things like exampleList)
+            return value;
+        } else if (typeof value === 'object') {
+            // Return objects as-is
+            return value;
+        } else {
+            console.warn(`⚠️  Translation value has unexpected type: ${keyPath}`);
+            return value;
+        }
+    }
+
+    /**
+     * Get English fallback for a translation key
+     * @param {string} keyPath - Dot-separated key path
+     * @param {object} replacements - Object with replacement values
+     * @returns {string|null} English translation or null if not found
+     */
+    getEnglishFallback(keyPath, replacements = {}) {
+        try {
+            const englishFile = path.join(this.uiLocalesDir, 'en.json');
+            if (fs.existsSync(englishFile)) {
+                const englishContent = fs.readFileSync(englishFile, 'utf8');
+                const englishTranslations = JSON.parse(englishContent);
+                
+                const keys = keyPath.split('.');
+                let value = englishTranslations;
+                
+                for (const key of keys) {
+                    if (value && typeof value === 'object' && key in value) {
+                        value = value[key];
+                    } else {
+                        return null;
+                    }
+                }
+                
+                if (typeof value === 'string') {
+                    // Replace placeholders in English fallback
+                    let result = value;
+                    for (const [placeholder, replacement] of Object.entries(replacements)) {
+                        result = result.replace(new RegExp(`\\{${placeholder}\\}`, 'g'), replacement);
+                    }
+                    return result;
+                }
+            }
+        } catch (error) {
+            // Silently fail and return null
+        }
+        return null;
+    }
+
+    /**
+     * Get current language code
+     * @returns {string} Current language code
+     */
+    getCurrentLanguage() {
+        return this.currentLanguage;
+    }
+
+    /**
+     * Get list of available languages
+     * @returns {Array} Array of language codes
+     */
+    getAvailableLanguages() {
+        return this.availableLanguages;
+    }
+
+    /**
+     * Change the current UI language
+     * @param {string} language - New language code
+     */
+    changeLanguage(language) {
+        this.loadLanguage(language);
+        this.saveLanguagePreference(language);
+    }
+
+    /**
+     * Get language display name
+     * @param {string} langCode - Language code
+     * @returns {string} Display name of the language
+     */
+    getLanguageDisplayName(langCode) {
+        const displayNames = {
+            'en': 'English',
+            'de': 'Deutsch (German)',
+            'es': 'Español (Spanish)',
+            'fr': 'Français (French)',
+            'ru': 'Русский (Russian)',
+            'ja': '日本語 (Japanese)',
+            'zh': '中文 (Chinese)'
+        };
+        return displayNames[langCode] || langCode;
+    }
+
+    /**
+     * Interactive language selection menu
+     * @returns {Promise<string>} Selected language code
+     */
+    async selectLanguage() {
+        // Use the existing readline interface from the manager if available
+        const rl = global.activeReadlineInterface;
+        
+        if (!rl) {
+            console.error('❌ No active readline interface available');
+            return this.currentLanguage;
+        }
+
+        return new Promise((resolve) => {
+            console.log('\n' + this.t('language.title'));
+            console.log(this.t('language.separator'));
+            console.log(this.t('language.current', { language: this.getLanguageDisplayName(this.currentLanguage) }));
+            console.log('\n' + this.t('language.available'));
+            
+            this.availableLanguages.forEach((lang, index) => {
+                const displayName = this.getLanguageDisplayName(lang);
+                const current = lang === this.currentLanguage ? ' ✓' : '';
+                console.log(`  ${index + 1}. ${displayName}${current}`);
+            });
+            
+            rl.question('\n' + this.t('language.prompt'), (answer) => {
+                const choice = parseInt(answer);
+                
+                if (choice === 0) {
+                    console.log(this.t('language.cancelled'));
+                    resolve(this.currentLanguage);
+                } else if (choice >= 1 && choice <= this.availableLanguages.length) {
+                    const selectedLang = this.availableLanguages[choice - 1];
+                    this.changeLanguage(selectedLang);
+                    console.log(this.t('language.changed', { language: this.getLanguageDisplayName(selectedLang) }));
+                    resolve(selectedLang);
+                } else {
+                    console.log(this.t('language.invalid'));
+                    resolve(this.currentLanguage);
+                }
+            });
+        });
+    }
+
+    /**
+     * Save language preference using settings manager
+     * @param {string} language - Language code to save
+     */
+    saveLanguagePreference(language) {
+        try {
+            const settings = settingsManager.getSettings();
+            settings.language = language;
+            settingsManager.saveSettings(settings);
+        } catch (error) {
+            console.error(`❌ Error saving language preference:`, error.message);
+        }
+    }
+
+    /**
+     * Refresh language from current settings
+     * Call this after settings changes to update UI language
+     */
+    refreshLanguageFromSettings() {
+        const settings = settingsManager.getSettings();
+        const configuredLanguage = settings.language;
+        
+        if (configuredLanguage && this.availableLanguages.includes(configuredLanguage)) {
+            if (configuredLanguage !== this.currentLanguage) {
+                this.loadLanguage(configuredLanguage);
+                console.log(`🌍 UI language updated to: ${this.getLanguageDisplayName(configuredLanguage)}`);
+            }
+        }
+    }
+
+    /**
+     * Remove the old loadUserConfig and saveUserConfig methods
+     * as they're now handled by settings-manager
+     */
+}
+
+// Export the class, not a singleton instance
+module.exports = UIi18n;

package/package.json

@@ -0,0 +1,152 @@
+{
+  "name": "i18ntk",
+  "version": "1.0.0",
+  "description": "i18ntk (i18n Toolkit) - A comprehensive, enterprise-grade internationalization (i18n) management toolkit for JavaScript/TypeScript projects with advanced analysis, validation, and automation features",
+  "keywords": [
+    "i18n",
+    "internationalization",
+    "localization",
+    "translation",
+    "management",
+    "toolkit",
+    "javascript",
+    "typescript",
+    "react",
+    "vue",
+    "angular",
+    "cli",
+    "automation",
+    "validation",
+    "analysis",
+    "enterprise",
+    "debugging",
+    "reporting"
+  ],
+  "homepage": "https://github.com/vladnoskv/i18n-management-toolkit#readme",
+  "bugs": {
+    "url": "https://github.com/vladnoskv/i18n-management-toolkit/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vladnoskv/i18n-management-toolkit.git"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/vladnoskv"
+  },
+  "license": "MIT",
+  "author": "Vladimir Noskov <vladnoskv@gmail.com> (https://github.com/vladnoskv)",
+  "type": "commonjs",
+  "main": "main/i18ntk-manage.js",
+  "bin": {
+    "i18ntk-manage": "main/i18ntk-manage.js",
+    "i18ntk-init": "main/i18ntk-init.js",
+    "i18ntk-analyze": "main/i18ntk-analyze.js",
+    "i18ntk-validate": "main/i18ntk-validate.js",
+    "i18ntk-usage": "main/i18ntk-usage.js",
+    "i18ntk-complete": "main/i18ntk-complete.js",
+    "i18ntk-sizing": "main/i18ntk-sizing.js",
+    "i18ntk-summary": "main/i18ntk-summary.js",
+    "i18ntk-autorun": "main/i18ntk-autorun.js",
+    "i18ntk-debug": "dev/debug/debugger.js"
+  },
+  "directories": {
+    "doc": "docs"
+  },
+  "files": [
+    "*.js",
+    "main/",
+    "utils/",
+    "scripts/",
+    "ui-locales/",
+    "locales/",
+    "docs/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node main/i18ntk-manage.js",
+    "i18ntk": "node main/i18ntk-manage.js",
+    "i18ntk:init": "node main/i18ntk-init.js",
+    "i18ntk:analyze": "node main/i18ntk-analyze.js",
+    "i18ntk:validate": "node main/i18ntk-validate.js",
+    "i18ntk:usage": "node main/i18ntk-usage.js",
+    "i18ntk:complete": "node main/i18ntk-complete.js",
+    "i18ntk:sizing": "node main/i18ntk-sizing.js",
+    "i18ntk:sizing:detailed": "node main/i18ntk-sizing.js --detailed",
+    "i18ntk:debug": "node main/i18ntk-manage.js --command=debug",
+    "i18ntk:settings": "node main/i18ntk-manage.js --command=settings",
+    "i18ntk:summary": "node main/i18ntk-summary.js",
+    "i18ntk:manage": "node main/i18ntk-manage.js",
+    "i18n:autorun": "node main/i18ntk-autorun.js",
+    "i18ntk:autorun": "node main/i18ntk-autorun.js",
+    "workflow": "node main/i18ntk-autorun.js",
+    "init": "node main/i18ntk-init.js",
+    "analyze": "node main/i18ntk-analyze.js",
+    "validate": "node main/i18ntk-validate.js",
+    "usage": "node main/i18ntk-usage.js",
+    "complete": "node main/i18ntk-complete.js",
+    "sizing": "node main/i18ntk-sizing.js",
+    "summary": "node main/i18ntk-summary.js",
+    "full-coverage": "npm run complete && npm run analyze",
+    "verify-package": "node scripts/verify-package.js",
+    "prepublishOnly": "npm run verify-package",
+    "test": "node utils/test-complete-system.js"
+  },
+  "dependencies": {
+    "html-parse-stringify": "^3.0.1",
+    "i18next": "^25.3.2",
+    "react": "^19.1.0",
+    "react-i18next": "^15.6.1",
+    "void-elements": "^3.1.0"
+  },
+  "devDependencies": {},
+  "peerDependencies": {
+    "i18next": ">=20.0.0",
+    "react-i18next": "^15.6.1"
+  },
+  "peerDependenciesMeta": {
+    "i18next": {
+      "optional": false
+    },
+    "react-i18next": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "preferGlobal": true,
+  "versionInfo": {
+    "version": "1.0.0",
+    "releaseDate": "27/07/2025",
+    "lastUpdated": "27/07/2025",
+    "maintainer": "Vladimir Noskov",
+    "changelog": "./CHANGELOG.md",
+    "documentation": "./README.md",
+    "apiReference": "./docs/api/API_REFERENCE.md",
+    "majorChanges": [
+      "🎉 First stable release of i18ntk - Enterprise-grade i18n management toolkit",
+      "✅ Complete CLI suite with 10 powerful commands for i18n management",
+      "🌍 Multi-language support with 7 built-in UI locales (EN, DE, ES, FR, JA, RU, ZH)",
+      "🔍 Advanced analysis and validation tools for translation quality",
+      "📊 Comprehensive reporting system with detailed insights",
+      "⚡ Automated workflows for efficient i18n management",
+      "🛠️ Framework support for React, Vue, Angular and more",
+      "📚 Complete documentation with installation guides and API reference"
+    ],
+    "breakingChanges": [],
+    "deprecations": [],
+    "nextVersion": "1.1.0",
+    "supportedNodeVersions": ">=16.0.0",
+    "supportedFrameworks": {
+      "react-i18next": ">=11.0.0",
+      "vue-i18n": ">=9.0.0",
+      "angular-i18n": ">=12.0.0"
+    }
+  }
+}

package/scripts/fix-missing-translation-keys.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+
+/**
+ * Fix Missing Translation Keys - v1.6.1
+ * 
+ * This script identifies and adds missing translation keys to all non-English
+ * language files to achieve 100% translation key coverage.
+ * 
+ * Usage: node scripts/fix-missing-translation-keys.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const UI_LOCALES_DIR = path.join(__dirname, '..', 'ui-locales');
+const ENGLISH_FILE = path.join(UI_LOCALES_DIR, 'en.json');
+
+// Language configurations with their names
+const LANGUAGES = {
+  'de': 'German',
+  'es': 'Spanish', 
+  'fr': 'French',
+  'ja': 'Japanese',
+  'ru': 'Russian',
+  'zh': 'Chinese'
+};
+
+/**
+ * Recursively get all keys from an object with dot notation
+ */
+function getAllKeys(obj, prefix = '') {
+  const keys = [];
+  
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      keys.push(...getAllKeys(value, fullKey));
+    } else {
+      keys.push(fullKey);
+    }
+  }
+  
+  return keys;
+}
+
+/**
+ * Get value from nested object using dot notation
+ */
+function getNestedValue(obj, path) {
+  return path.split('.').reduce((current, key) => current?.[key], obj);
+}
+
+/**
+ * Set value in nested object using dot notation
+ */
+function setNestedValue(obj, path, value) {
+  const keys = path.split('.');
+  const lastKey = keys.pop();
+  
+  let current = obj;
+  for (const key of keys) {
+    if (!(key in current) || typeof current[key] !== 'object') {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  
+  current[lastKey] = value;
+}
+
+/**
+ * Load and parse JSON file
+ */
+function loadJsonFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`❌ Error loading ${filePath}: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Save JSON file with proper formatting
+ */
+function saveJsonFile(filePath, data) {
+  try {
+    const content = JSON.stringify(data, null, 2);
+    fs.writeFileSync(filePath, content, 'utf8');
+    return true;
+  } catch (error) {
+    console.error(`❌ Error saving ${filePath}: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Generate placeholder translation for missing keys
+ */
+function generatePlaceholderTranslation(englishValue, language) {
+  // For simple strings, add a language prefix to indicate it needs translation
+  if (typeof englishValue === 'string') {
+    // Don't translate emoji-only strings or very short technical strings
+    if (/^[\u{1F300}-\u{1F9FF}\s]*$/u.test(englishValue) || englishValue.length <= 3) {
+      return englishValue;
+    }
+    
+    // Add language indicator for strings that need translation
+    return `[${language.toUpperCase()}] ${englishValue}`;
+  }
+  
+  return englishValue;
+}
+
+/**
+ * Main function to fix missing translation keys
+ */
+async function fixMissingTranslationKeys() {
+  console.log('🔧 I18N Translation Key Fixer - v1.6.1');
+  console.log('========================================\n');
+  
+  // Load English reference file
+  console.log('📖 Loading English reference file...');
+  const englishData = loadJsonFile(ENGLISH_FILE);
+  if (!englishData) {
+    console.error('❌ Failed to load English reference file');
+    process.exit(1);
+  }
+  
+  const englishKeys = getAllKeys(englishData);
+  console.log(`✅ Found ${englishKeys.length} keys in English file\n`);
+  
+  let totalKeysAdded = 0;
+  const results = {};
+  
+  // Process each language
+  for (const [langCode, langName] of Object.entries(LANGUAGES)) {
+    console.log(`🔄 Processing ${langName} (${langCode})...`);
+    
+    const langFile = path.join(UI_LOCALES_DIR, `${langCode}.json`);
+    const langData = loadJsonFile(langFile);
+    
+    if (!langData) {
+      console.log(`⚠️  Skipping ${langName} - file not found or invalid`);
+      continue;
+    }
+    
+    const langKeys = getAllKeys(langData);
+    const missingKeys = englishKeys.filter(key => !langKeys.includes(key));
+    
+    console.log(`   📊 Current keys: ${langKeys.length}`);
+    console.log(`   ⚠️  Missing keys: ${missingKeys.length}`);
+    
+    if (missingKeys.length === 0) {
+      console.log(`   ✅ No missing keys found\n`);
+      results[langCode] = { added: 0, total: langKeys.length };
+      continue;
+    }
+    
+    // Add missing keys
+    let addedCount = 0;
+    for (const missingKey of missingKeys) {
+      const englishValue = getNestedValue(englishData, missingKey);
+      const translatedValue = generatePlaceholderTranslation(englishValue, langCode);
+      
+      setNestedValue(langData, missingKey, translatedValue);
+      addedCount++;
+    }
+    
+    // Save updated file
+    if (saveJsonFile(langFile, langData)) {
+      console.log(`   ✅ Added ${addedCount} keys to ${langName}`);
+      console.log(`   💾 Updated ${langFile}\n`);
+      
+      totalKeysAdded += addedCount;
+      results[langCode] = { added: addedCount, total: langKeys.length + addedCount };
+    } else {
+      console.log(`   ❌ Failed to save ${langName} file\n`);
+    }
+  }
+  
+  // Summary report
+  console.log('📊 SUMMARY REPORT');
+  console.log('==================');
+  console.log(`📖 English reference keys: ${englishKeys.length}`);
+  console.log(`➕ Total keys added: ${totalKeysAdded}`);
+  console.log(`🌐 Languages processed: ${Object.keys(results).length}\n`);
+  
+  console.log('📋 Language Details:');
+  for (const [langCode, result] of Object.entries(results)) {
+    const langName = LANGUAGES[langCode];
+    const percentage = ((result.total / englishKeys.length) * 100).toFixed(1);
+    console.log(`   ${langName} (${langCode}): ${result.total}/${englishKeys.length} keys (${percentage}%) - Added: ${result.added}`);
+  }
+  
+  console.log('\n🎉 Translation key fixing completed!');
+  console.log('\n📋 Next Steps:');
+  console.log('1. Review the added placeholder translations');
+  console.log('2. Replace [LANG] prefixed strings with proper translations');
+  console.log('3. Run npm test to verify translation consistency');
+  console.log('4. Update version to 1.6.1 when translations are complete');
+}
+
+// Run the script
+if (require.main === module) {
+  fixMissingTranslationKeys().catch(error => {
+    console.error('❌ Script failed:', error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = { fixMissingTranslationKeys };