i18ntk 3.3.0 → 4.1.0

package/main/i18ntk-sizing.js

@@ -41,15 +41,17 @@ const { logger } = require('../utils/logger');
 const { getGlobalReadline, closeGlobalReadline } = require('../utils/cli');
 const SetupEnforcer = require('../utils/setup-enforcer');
 
-// Ensure setup is complete before running
-(async () => {
-  try {
-    await SetupEnforcer.checkSetupCompleteAsync();
-  } catch (error) {
-    console.error('Setup check failed:', error.message);
-    process.exit(1);
-  }
-})();
+// Ensure setup is complete before running (only when executed directly)
+if (require.main === module) {
+  (async () => {
+    try {
+      await SetupEnforcer.checkSetupCompleteAsync();
+    } catch (error) {
+      console.error('Setup check failed:', error.message);
+      process.exit(1);
+    }
+  })();
+}
 
 loadTranslations();
 
@@ -82,9 +84,11 @@ class I18nSizingAnalyzer {
     this.format = options.format || 'table';
     this.outputReport = options.outputReport || false;
     this.sourceLanguage = options.sourceLanguage || config.sourceLanguage || 'en';
-    this.detailed = options.detailed || false;
-    this.detailedKeys = options.detailedKeys || false;
-    this.rl = null;
+    this.detailed = options.detailed || false;
+    this.detailedKeys = options.detailedKeys || false;
+    this.predictExpansion = options.predictExpansion || false;
+    this.rl = null;
+    this.expansionPredictions = null;
     
     // Initialize i18n with UI language from config
     const uiLanguage = options.uiLanguage || config.uiLanguage || 'en';
@@ -490,8 +494,13 @@ class I18nSizingAnalyzer {
     });
     this.generateFileComparison();
 
-    // Generate recommendations
-    this.generateRecommendations();
+    // Generate recommendations
+    this.generateRecommendations();
+
+    // Generate expansion predictions if requested
+    if (this.predictExpansion) {
+      this.generateExpansionPredictions();
+    }
   }
 
   generateFileComparison() {
@@ -557,6 +566,145 @@ class I18nSizingAnalyzer {
     this.stats.summary.recommendations = recommendations;
   }
 
+  // Language pair expansion reference table (average % expansion from English)
+  // Values represent typical character count ratio (target/source) minus 1, as percentage
+  getExpansionReference() {
+    return {
+      de: 35, es: 25, fr: 20, it: 15, pt: 20, nl: 30, sv: 15,
+      ru: 50, uk: 45, pl: 30, cs: 25, sk: 25, bg: 40, sr: 40,
+      ja: -40, zh: -45, ko: -35, th: -30, vi: -20, km: -5,
+      ar: 15, he: 10, fa: 20, tr: 10, fi: 25, hu: 20, el: 15,
+      da: 10, nb: 10, ro: 15, id: 5, ms: 5, hi: 15, bn: 20,
+      ta: 10, te: 15, mr: 20, gu: 20, ml: 25, kn: 15
+    };
+  }
+
+  classifyExpansionRisk(ratio) {
+    const absRatio = Math.abs(ratio);
+    if (absRatio < 30) return { tier: 'safe', label: 'Safe', color: 'green' };
+    if (absRatio < 50) return { tier: 'warning', label: 'Warning', color: 'yellow' };
+    return { tier: 'critical', label: 'Critical', color: 'red' };
+  }
+
+  generateExpansionPredictions() {
+    const languages = Object.keys(this.stats.languages);
+    if (languages.length < 2) return;
+
+    const baseLanguage = this.stats.summary.baseLanguage || this.config.sourceLanguage || 'en';
+    const expansionRef = this.getExpansionReference();
+    const predictions = {
+      baseLanguage,
+      perLanguage: {},
+      perKey: {},
+      topExpandedKeys: [],
+      summary: { safe: 0, warning: 0, critical: 0, total: 0 }
+    };
+
+    for (const lang of languages) {
+      if (lang === baseLanguage) continue;
+
+      const baseStats = this.stats.languages[baseLanguage];
+      const langStats = this.stats.languages[lang];
+      if (!baseStats || !langStats) continue;
+
+      const actualRatio = baseStats.totalCharacters > 0
+        ? ((langStats.totalCharacters - baseStats.totalCharacters) / baseStats.totalCharacters) * 100
+        : 0;
+
+      const referenceRatio = expansionRef[lang] || 10;
+      const risk = this.classifyExpansionRisk(actualRatio);
+      predictions.perLanguage[lang] = {
+        actualExpansionPercent: Math.round(actualRatio * 100) / 100,
+        referenceExpansionPercent: referenceRatio,
+        riskTier: risk.tier,
+        riskLabel: risk.label,
+        totalKeys: langStats.totalKeys,
+        totalChars: langStats.totalCharacters
+      };
+    }
+
+    const keyEntries = [];
+    for (const [key, langData] of Object.entries(this.stats.keys)) {
+      const baseData = langData[baseLanguage];
+      if (!baseData || baseData.length === 0) continue;
+
+      const keyPredictions = {};
+      for (const [lang, data] of Object.entries(langData)) {
+        if (lang === baseLanguage) continue;
+        const ratio = ((data.length - baseData.length) / baseData.length) * 100;
+        const risk = this.classifyExpansionRisk(ratio);
+        keyPredictions[lang] = {
+          sourceLength: baseData.length,
+          targetLength: data.length,
+          expansionPercent: Math.round(ratio * 100) / 100,
+          riskTier: risk.tier
+        };
+        predictions.summary[risk.tier]++;
+        predictions.summary.total++;
+      }
+
+      const maxExpansion = Math.max(...Object.values(keyPredictions).map(p => Math.abs(p.expansionPercent)));
+      keyEntries.push({ key, maxExpansion, predictions: keyPredictions });
+    }
+
+    keyEntries.sort((a, b) => b.maxExpansion - a.maxExpansion);
+    predictions.topExpandedKeys = keyEntries.slice(0, 30);
+    predictions.perKey = Object.fromEntries(keyEntries.slice(0, 200).map(e => [e.key, e.predictions]));
+
+    this.expansionPredictions = predictions;
+    this.stats.expansionPredictions = predictions;
+  }
+
+  displayExpansionPredictions() {
+    if (!this.expansionPredictions) return;
+
+    const p = this.expansionPredictions;
+    console.log('\n' + '='.repeat(60));
+    console.log('  EXPANSION PREDICTION ANALYSIS');
+    console.log('='.repeat(60));
+    console.log(`  Base Language: ${p.baseLanguage}`);
+    console.log(`  Total Key-Language Pairs Analyzed: ${p.summary.total}`);
+    console.log(`  Safe (<30%): ${p.summary.safe} | Warning (30-50%): ${p.summary.warning} | Critical (>50%): ${p.summary.critical}`);
+
+    console.log('\n  PER-LANGUAGE EXPANSION RATIOS:');
+    const langRows = Object.entries(p.perLanguage).map(([lang, data]) => ({
+      language: lang,
+      actual: `${data.actualExpansionPercent > 0 ? '+' : ''}${data.actualExpansionPercent}%`,
+      reference: `${data.referenceExpansionPercent > 0 ? '+' : ''}${data.referenceExpansionPercent}%`,
+      risk: data.riskLabel
+    }));
+    console.log(this.createTable([
+      { key: 'language', label: 'Language' },
+      { key: 'actual', label: 'Actual', align: 'right' },
+      { key: 'reference', label: 'Reference', align: 'right' },
+      { key: 'risk', label: 'Risk Tier' }
+    ], langRows));
+
+    if (p.topExpandedKeys.length > 0) {
+      console.log('\n  TOP EXPANDED KEYS (highest risk of UI overflow):');
+      const keyRows = p.topExpandedKeys.slice(0, 15).map(entry => {
+        const langs = Object.entries(entry.predictions).map(([l, d]) =>
+          `${l}:${d.expansionPercent > 0 ? '+' : ''}${d.expansionPercent}%`
+        ).join(' ');
+        return { key: entry.key, maxExp: `${entry.maxExpansion > 0 ? '+' : ''}${Math.round(entry.maxExpansion)}%`, languages: langs };
+      });
+      console.log(this.createTable([
+        { key: 'key', label: 'Key' },
+        { key: 'maxExp', label: 'Max Exp', align: 'right' },
+        { key: 'languages', label: 'Per-Language' }
+      ], keyRows));
+    }
+
+    console.log('\n  RECOMMENDATIONS:');
+    if (p.summary.critical > 0) {
+      console.log(`  - ${p.summary.critical} key-language pairs have >50% expansion — review UI layouts for truncation risk`);
+    }
+    if (p.summary.warning > 0) {
+      console.log(`  - ${p.summary.warning} key-language pairs have 30-50% expansion — test on target languages`);
+    }
+    console.log('  - Use the reference expansion ratios to plan UI element sizing for unsupported languages');
+  }
+
   // Display concise folder-level results
   displayFolderResults() {
     console.log("\n" + t("sizing.sizing_analysis_results"));
@@ -616,9 +764,13 @@ class I18nSizingAnalyzer {
       reportPath: this.outputDir
     }));
     
-    if (this.detailedKeys) {
-      this.displayDetailedKeys();
-    }
+    if (this.detailedKeys) {
+      this.displayDetailedKeys();
+    }
+
+    if (this.predictExpansion && this.expansionPredictions) {
+      this.displayExpansionPredictions();
+    }
   }
 
   displayFileComparison() {
@@ -874,17 +1026,50 @@ Generated: ${new Date().toISOString()}
         report += `
 ### ${key}
 `;
-        Object.entries(data).forEach(([lang, keyData]) => {
-          const length = keyData.length;
-          const isEmpty = length === 0;
-          const isLong = length > this.threshold;
-          const status = isEmpty ? 'EMPTY' : isLong ? 'LONG' : 'OK';
-          report += `- ${lang}: ${length} chars [${status}]\n`;
-        });
+        Object.entries(data).forEach(([lang, keyData]) => {
+          const length = keyData.length;
+          const isEmpty = length === 0;
+          const isLong = length > this.threshold;
+          const status = isEmpty ? 'EMPTY' : isLong ? 'LONG' : 'OK';
+          report += `- ${lang}: ${length} chars [${status}]\n`;
+        });
+      });
+    }
+
+    // Expansion predictions
+    if (this.expansionPredictions) {
+      const ep = this.expansionPredictions;
+      report += `
+## Expansion Prediction Analysis
+
+### Summary
+- Base Language: ${ep.baseLanguage}
+- Safe (<30%): ${ep.summary.safe}
+- Warning (30-50%): ${ep.summary.warning}
+- Critical (>50%): ${ep.summary.critical}
+- Total Pairs: ${ep.summary.total}
+
+### Per-Language Ratios
+`;
+      Object.entries(ep.perLanguage).forEach(([lang, data]) => {
+        report += `- ${lang}: ${data.actualExpansionPercent > 0 ? '+' : ''}${data.actualExpansionPercent}% (ref: ${data.referenceExpansionPercent > 0 ? '+' : ''}${data.referenceExpansionPercent}%) [${data.riskLabel}]\n`;
       });
+
+      if (ep.topExpandedKeys.length > 0) {
+        report += `
+### Top Expanded Keys
+`;
+        ep.topExpandedKeys.slice(0, 30).forEach((entry, idx) => {
+          report += `${idx + 1}. ${entry.key} (max: ${entry.maxExpansion > 0 ? '+' : ''}${Math.round(entry.maxExpansion)}%)\n`;
+          Object.entries(entry.predictions).forEach(([l, d]) => {
+            report += `   ${l}: ${d.sourceLength} → ${d.targetLength} chars (${d.expansionPercent > 0 ? '+' : ''}${d.expansionPercent}%) [${d.riskTier}]\n`;
+          });
+          report += '\n';
+        });
+      }
     }
 
-    return report;
+    return report;
   }
 
   // Generate CSV report
@@ -917,45 +1102,7 @@ Generated: ${new Date().toISOString()}
     }
   }
 
-  // Main analysis method
-  async analyze() {
-    const startTime = Date.now();
-    
-    try {
-        logger.info(t("sizing.starting_i18n_sizing_analysis"));
-        logger.info(t("sizing.source_directory", { sourceDir: this.sourceDir }));
-      
-      const files = this.getLanguageFiles();
-      
-      if (files.length === 0) {
-          logger.warn(t("sizing.no_translation_files_found"));
-          return;
-      }
-      
-      logger.info(t("sizing.found_languages", { languages: files.map(f => f.language).join(', ') }));
-      
-      this.analyzeFileSizes(files);
-      this.analyzeTranslationContent(files);
-      this.generateSizeComparison();
-      
-      if (this.format === 'table') {
-        this.displayFolderResults();
-      } else if (this.format === 'json') {
-          logger.info(t("sizing.analysisStats", { stats: JSON.stringify(this.stats, null, 2) }));
-      }
-      
-      await this.generateHumanReadableReport();
-      
-      const endTime = Date.now();
-      logger.info(t("sizing.analysis_completed", { duration: ((endTime - startTime) / 1000).toFixed(2) }));
-      
-    } catch (error) {
-        logger.error(t("sizing.analysis_failed", { errorMessage: error.message }));
-        process.exit(1);
-    }
-  }
-
-  // Parse command line arguments without yargs
+  // Parse command line arguments without yargs
   parseArgs() {
     const args = process.argv.slice(2);
     const options = {
@@ -1018,6 +1165,8 @@ Generated: ${new Date().toISOString()}
           options.d = options.detailed;
         } else if (key === 'detailed-keys') {
           options['detailed-keys'] = value.toLowerCase() !== 'false';
+        } else if (key === 'predict-expansion') {
+          options['predict-expansion'] = value.toLowerCase() !== 'false';
         } else if (key === 'output-dir') {
           options['output-dir'] = value;
         }
@@ -1073,17 +1222,24 @@ Generated: ${new Date().toISOString()}
             options.detailed = true;
             options.d = true;
           }
-        } else if (key === 'detailed-keys') {
-          if (nextArg && !nextArg.startsWith('-') && ['true', 'false'].includes(nextArg.toLowerCase())) {
-            options['detailed-keys'] = nextArg.toLowerCase() !== 'false';
-            i++;
-          } else {
-            options['detailed-keys'] = true;
-          }
-        } else if (key === 'output-dir') {
-          options['output-dir'] = nextArg || options['output-dir'];
-          if (nextArg && !nextArg.startsWith('-')) i++;
-        }
+        } else if (key === 'detailed-keys') {
+          if (nextArg && !nextArg.startsWith('-') && ['true', 'false'].includes(nextArg.toLowerCase())) {
+            options['detailed-keys'] = nextArg.toLowerCase() !== 'false';
+            i++;
+          } else {
+            options['detailed-keys'] = true;
+          }
+        } else if (key === 'predict-expansion') {
+          if (nextArg && !nextArg.startsWith('-') && ['true', 'false'].includes(nextArg.toLowerCase())) {
+            options['predict-expansion'] = nextArg.toLowerCase() !== 'false';
+            i++;
+          } else {
+            options['predict-expansion'] = true;
+          }
+        } else if (key === 'output-dir') {
+          options['output-dir'] = nextArg || options['output-dir'];
+          if (nextArg && !nextArg.startsWith('-')) i++;
+        }
       }
     }
     
@@ -1102,6 +1258,7 @@ Options:
   --source-language <code>    Source language baseline for comparisons (default: en)
   -d, --detailed              Generate detailed report with more information
   --detailed-keys             Show detailed key-level analysis
+  --predict-expansion         Predict UI layout expansion risk per language
   --output-dir <dir>          Output directory for reports (default: ./i18ntk-reports)
   --help                  Show this help message
 `);
@@ -1124,8 +1281,9 @@ Options:
     this.languages = args.languages ? args.languages.split(',').map(l => l.trim()) : [];
     this.outputReport = args['output-report'] !== undefined ? args['output-report'] : false;
     this.format = args.format || 'table';
-    this.detailed = args.detailed;
-    this.detailedKeys = args['detailed-keys'];
+    this.detailed = args.detailed;
+    this.detailedKeys = args['detailed-keys'];
+    this.predictExpansion = args['predict-expansion'] || false;
     this.sourceLanguage = args['source-language'] || config.sourceLanguage || this.sourceLanguage || 'en';
 
     if (!fromMenu) {
@@ -1141,7 +1299,7 @@ Options:
         
         const cliHelper = require('../utils/cli-helper');
         const pin = await cliHelper.promptPin(t('adminCli.enterPin'));
-        const isValid = await this.adminAuth.verifyPin(pin);
+        const isValid = await adminAuth.verifyPin(pin);
         
         if (!isValid) {
           console.log(t('adminCli.invalidPin'));
@@ -1183,7 +1341,11 @@ Options:
       this.generateSizeComparison();
       
       // Display results
-      this.displayFolderResults();
+      if (this.format === 'table') {
+        this.displayFolderResults();
+      } else if (this.format === 'json') {
+          logger.info(t("sizing.analysisStats", { stats: JSON.stringify(this.stats, null, 2) }));
+      }
       
       // Generate reports if requested
       await this.generateHumanReadableReport();