i18ntk 3.3.0 → 4.0.0

package/main/i18ntk-scanner.js

@@ -109,49 +109,64 @@ class I18nTextScanner {
     const args = process.argv.slice(2);
     const parsed = {};
 
-    args.forEach(arg => {
-      if (arg.startsWith('--')) {
-        const [key, ...valueParts] = arg.substring(2).split('=');
-        const value = valueParts.join('=');
-
-        switch (key) {
-          case 'source-dir':
-            parsed.sourceDir = value || '';
-            break;
-          case 'framework':
-            parsed.framework = value || '';
-            break;
-          case 'patterns':
-            parsed.patterns = value ? value.split(',').map(p => p.trim()).filter(Boolean) : [];
-            break;
-          case 'exclude':
-            parsed.exclude = value ? value.split(',').map(e => e.trim()).filter(Boolean) : [];
-            break;
-          case 'output-dir':
-            parsed.outputDir = value || '';
-            break;
-          case 'min-length':
-            parsed.minLength = parseInt(value) || 3;
-            break;
-          case 'max-length':
-            parsed.maxLength = parseInt(value) || 100;
-            break;
-          case 'output-report':
-            parsed.outputReport = true;
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (arg.startsWith('--')) {
+        const [key, ...valueParts] = arg.substring(2).split('=');
+        let value = valueParts.join('=');
+        if (!value && args[i + 1] && !args[i + 1].startsWith('--')) {
+          value = args[i + 1];
+        }
+
+        switch (key) {
+          case 'source-dir':
+            parsed.sourceDir = value || '';
+            if (value === args[i + 1]) i++;
+            break;
+          case 'framework':
+            parsed.framework = value || '';
+            if (value === args[i + 1]) i++;
+            break;
+          case 'patterns':
+            parsed.patterns = value ? value.split(',').map(p => p.trim()).filter(Boolean) : [];
+            if (value === args[i + 1]) i++;
+            break;
+          case 'exclude':
+            parsed.exclude = value ? value.split(',').map(e => e.trim()).filter(Boolean) : [];
+            if (value === args[i + 1]) i++;
+            break;
+          case 'output-dir':
+            parsed.outputDir = value || '';
+            if (value === args[i + 1]) i++;
+            break;
+          case 'min-length':
+            parsed.minLength = parseInt(value) || 3;
+            if (value === args[i + 1]) i++;
+            break;
+          case 'max-length':
+            parsed.maxLength = parseInt(value) || 100;
+            if (value === args[i + 1]) i++;
+            break;
+          case 'output-report':
+            parsed.outputReport = true;
             break;
           case 'include-tests':
-            parsed.includeTests = true;
-            break;
-          case 'help':
-          case 'h':
-            parsed.help = true;
-            break;
-        }
-      }
-    });
-
-    return parsed;
-  }
+            parsed.includeTests = true;
+            break;
+          case 'source-language':
+            parsed.sourceLanguage = value || '';
+            if (value === args[i + 1]) i++;
+            break;
+          case 'help':
+          case 'h':
+            parsed.help = true;
+            break;
+        }
+      }
+    }
+
+    return parsed;
+  }
 
   detectFramework(projectRoot) {
     const packagePath = path.join(projectRoot, 'package.json');
@@ -293,43 +308,148 @@ class I18nTextScanner {
   }
 
   isEnglishText(text) {
-    // Enhanced text detection for Unicode and multilingual support
     const trimmed = text.trim();
     if (trimmed.length < 3) return false;
 
-    // Skip if it's just numbers or special characters
     if (/^\d+$/.test(trimmed)) return false;
     if (/^[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>?]+$/.test(trimmed)) return false;
 
-    // Allow Unicode characters including CJK, Cyrillic, etc.
     const validChars = trimmed.match(/[\p{L}\p{N}\s\-,.!?':"()\[\]{}]/gu) || [];
     const validRatio = validChars.length / trimmed.length;
 
-    // Must have at least 50% valid characters and some alphabetic characters
     const hasAlpha = /[a-zA-Z\u00C0-\u024F\u1E00-\u1EFF\u0400-\u04FF\u4E00-\u9FFF\uAC00-\uD7AF]/u.test(trimmed);
 
     return validRatio >= 0.5 && hasAlpha;
   }
 
+  getLanguageProfile(langCode) {
+    const profiles = {
+      en: {
+        name: 'English',
+        charRegex: /[a-zA-Z\u00C0-\u024F]/u,
+        stopwords: ['the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can', 'had', 'her', 'was', 'one', 'our', 'out', 'has', 'have', 'from', 'they', 'that', 'with', 'this', 'will', 'your', 'which', 'their', 'them', 'than', 'then', 'been', 'being', 'would', 'should', 'could', 'about', 'after'],
+        minLength: 3,
+        maxLength: 150
+      },
+      de: {
+        name: 'German',
+        charRegex: /[a-zA-Z\u00C0-\u00FF\u0100-\u017F\u00DF\u1E00-\u1EFF]/u,
+        stopwords: ['der', 'die', 'das', 'und', 'ist', 'von', 'mit', 'sich', 'des', 'auf', 'dem', 'nicht', 'ein', 'eine', 'auch', 'als', 'aus', 'bei', 'nach', 'wie', 'oder', 'war', 'hat', 'ich', 'sie', 'einem', 'um', 'am', 'im', 'es'],
+        minLength: 3,
+        maxLength: 180
+      },
+      fr: {
+        name: 'French',
+        charRegex: /[a-zA-Z\u00C0-\u00FF\u0152\u0153]/u,
+        stopwords: ['le', 'la', 'les', 'des', 'est', 'pas', 'que', 'une', 'dans', 'sur', 'plus', 'par', 'pour', 'avec', 'aux', 'ces', 'ses', 'mes', 'tes', 'notre', 'votre', 'leur', 'dont', 'sont', 'comme', 'mais', 'alors', 'peut', 'tout', 'tous', 'fait'],
+        minLength: 3,
+        maxLength: 170
+      },
+      es: {
+        name: 'Spanish',
+        charRegex: /[a-zA-Z\u00C0-\u00FF\u00F1\u00D1]/u,
+        stopwords: ['que', 'los', 'las', 'del', 'como', 'por', 'para', 'con', 'una', 'sus', 'muy', 'más', 'pero', 'este', 'esta', 'hay', 'son', 'eran', 'fue', 'han', 'será', 'está', 'todo', 'otro', 'otra'],
+        minLength: 3,
+        maxLength: 150
+      },
+      ja: {
+        name: 'Japanese',
+        charRegex: /[\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FFF\uFF66-\uFF9F]/u,
+        stopwords: ['の', 'に', 'は', 'を', 'た', 'が', 'で', 'て', 'と', 'し', 'れ', 'さ', 'る', 'す', 'ん', 'な', 'い', 'か', 'ま', 'も', 'こ', 'り', 'ち', 'き', 'ょ', 'う'],
+        minLength: 2,
+        maxLength: 80
+      },
+      zh: {
+        name: 'Chinese',
+        charRegex: /[\u4E00-\u9FFF\u3400-\u4DBF\uF900-\uFAFF]/u,
+        stopwords: ['的', '是', '在', '不', '了', '有', '和', '人', '这', '中', '大', '为', '上', '个', '国', '我', '以', '要', '他', '时', '来', '用', '们', '生', '到', '作', '地'],
+        minLength: 1,
+        maxLength: 50
+      },
+      ru: {
+        name: 'Russian',
+        charRegex: /[\u0400-\u04FF\u0500-\u052F]/u,
+        stopwords: ['и', 'в', 'не', 'на', 'что', 'как', 'по', 'к', 'от', 'это', 'за', 'то', 'для', 'все', 'его', 'она', 'так', 'же', 'но', 'был', 'быть', 'еще', 'уже', 'кто', 'мой', 'ее', 'их', 'из'],
+        minLength: 2,
+        maxLength: 200
+      },
+      ko: {
+        name: 'Korean',
+        charRegex: /[\uAC00-\uD7AF\u1100-\u11FF\u3130-\u318F]/u,
+        stopwords: ['이', '그', '저', '것', '수', '등', '들', '및', '년', '월', '일', '에서', '에게', '으로', '보다', '에게서', '의', '에', '는', '은', '가', '를', '과', '와', '도', '만', '까지', '부터'],
+        minLength: 1,
+        maxLength: 70
+      },
+      ar: {
+        name: 'Arabic',
+        charRegex: /[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF]/u,
+        stopwords: ['في', 'من', 'على', 'عن', 'مع', 'هو', 'هي', 'كان', 'هذا', 'ذلك', 'بين', 'بعد', 'قبل', 'عند', 'حتى', 'الى', 'او', 'لا', 'ما', 'لم', 'لن', 'كل', 'بعض', 'أي'],
+        minLength: 2,
+        maxLength: 150
+      },
+      hi: {
+        name: 'Hindi',
+        charRegex: /[\u0900-\u097F]/u,
+        stopwords: ['का', 'की', 'के', 'है', 'हैं', 'था', 'थे', 'होगा', 'होगी', 'में', 'से', 'पर', 'को', 'तक', 'और', 'या', 'लेकिन', 'जब', 'तब', 'कि', 'यह', 'वह', 'एक', 'दो'],
+        minLength: 2,
+        maxLength: 160
+      },
+      vanilla: {
+        name: 'Generic Latin',
+        charRegex: /[a-zA-Z\u00C0-\u024F]/u,
+        stopwords: [],
+        minLength: 3,
+        maxLength: 150
+      }
+    };
+    return profiles[langCode] || profiles.en;
+  }
+
+  isTextInLanguage(text, langCode) {
+    const profile = this.getLanguageProfile(langCode);
+    const trimmed = text.trim();
+
+    if (trimmed.length < profile.minLength) return false;
+    if (trimmed.length > profile.maxLength) return false;
+
+    if (/^\d+$/.test(trimmed)) return false;
+    if (/^[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>?]+$/.test(trimmed)) return false;
+
+    const hasScriptChar = profile.charRegex.test(trimmed);
+    if (!hasScriptChar) return false;
+
+    if (profile.stopwords.length > 0) {
+      const words = trimmed.toLowerCase().split(/\s+/);
+      for (const word of words) {
+        if (profile.stopwords.includes(word)) return true;
+      }
+      const validChars = trimmed.match(/[\p{L}\p{N}\s\-,.!?':"()\[\]{}]/gu) || [];
+      const validRatio = validChars.length / trimmed.length;
+      return validRatio >= 0.5;
+    }
+
+    return true;
+  }
+
   scanFile(filePath, patterns, minLength, maxLength) {
     try {
       const content = SecurityUtils.safeReadFileSync(filePath, path.dirname(filePath), 'utf8');
       const lines = content.split('\n');
       const results = [];
+      const sourceLang = this.config.sourceLanguage || 'en';
 
       patterns.forEach(pattern => {
         let match;
         while ((match = pattern.exec(content)) !== null) {
           const text = match[1] || match[0];
 
-          // Skip translation function calls
           const beforeMatch = content.substring(Math.max(0, match.index - 20), match.index);
           if (beforeMatch.includes('t(') || beforeMatch.includes('i18next.t(') ||
               beforeMatch.includes('$t(') || beforeMatch.includes('translate(')) {
             continue;
           }
 
-          if (text && this.isEnglishText(text) &&
+          if (text && this.isTextInLanguage(text, sourceLang) &&
               text.length >= minLength && text.length <= maxLength) {
 
             const lineNumber = content.substring(0, match.index).split('\n').length;
@@ -355,7 +475,23 @@ class I18nTextScanner {
   }
 
   generateSuggestion(text) {
-    const key = text.toLowerCase()
+    const sourceLang = this.config.sourceLanguage || 'en';
+    const transliterations = {
+      ja: { 'あ': 'a', 'い': 'i', 'う': 'u', 'え': 'e', 'お': 'o', 'か': 'ka', 'き': 'ki', 'く': 'ku', 'け': 'ke', 'こ': 'ko', 'さ': 'sa', 'し': 'shi', 'す': 'su', 'せ': 'se', 'そ': 'so', 'た': 'ta', 'ち': 'chi', 'つ': 'tsu', 'て': 'te', 'と': 'to', 'な': 'na', 'に': 'ni', 'ぬ': 'nu', 'ね': 'ne', 'の': 'no', 'は': 'ha', 'ひ': 'hi', 'ふ': 'fu', 'へ': 'he', 'ほ': 'ho', 'ま': 'ma', 'み': 'mi', 'む': 'mu', 'め': 'me', 'も': 'mo', 'や': 'ya', 'ゆ': 'yu', 'よ': 'yo', 'ら': 'ra', 'り': 'ri', 'る': 'ru', 'れ': 're', 'ろ': 'ro', 'わ': 'wa', 'を': 'wo', 'ん': 'n' },
+      ru: { 'а': 'a', 'б': 'b', 'в': 'v', 'г': 'g', 'д': 'd', 'е': 'e', 'ё': 'yo', 'ж': 'zh', 'з': 'z', 'и': 'i', 'й': 'y', 'к': 'k', 'л': 'l', 'м': 'm', 'н': 'n', 'о': 'o', 'п': 'p', 'р': 'r', 'с': 's', 'т': 't', 'у': 'u', 'ф': 'f', 'х': 'kh', 'ц': 'ts', 'ч': 'ch', 'ш': 'sh', 'щ': 'sch', 'ъ': '', 'ы': 'y', 'ь': '', 'э': 'e', 'ю': 'yu', 'я': 'ya' },
+      zh: { '的': 'de', '一': 'yi', '是': 'shi', '在': 'zai', '不': 'bu', '了': 'le', '有': 'you', '和': 'he', '人': 'ren', '这': 'zhe', '中': 'zhong', '大': 'da', '为': 'wei', '上': 'shang', '个': 'ge', '国': 'guo', '我': 'wo', '以': 'yi_t', '要': 'yao', '他': 'ta', '时': 'shi_t', '来': 'lai', '用': 'yong', '们': 'men', '生': 'sheng', '到': 'dao', '作': 'zuo', '地': 'di' }
+    };
+
+    let transliterated = text;
+    const table = transliterations[sourceLang];
+    if (table) {
+      transliterated = '';
+      for (const ch of text) {
+        transliterated += table[ch] || ch;
+      }
+    }
+
+    const key = transliterated.toLowerCase()
       .replace(/[^a-z0-9\s]/g, '')
       .replace(/\s+/g, '_')
       .substring(0, 50);
@@ -559,6 +695,9 @@ class I18nTextScanner {
 
     this.sourceDir = this.config.sourceDir || './src';
 
+    // Source language for multi-language detection
+    this.sourceLanguage = args['source-language'] || this.config.sourceLanguage || 'en';
+
     // Resolve framework with precedence: CLI arg > config.framework.preference|string > auto-detect > fallback
     const cliFramework = args.framework;
     const cfgFramework = this.config.framework;
@@ -637,4 +776,4 @@ if (require.main === module) {
   })();
 }
 
-module.exports = I18nTextScanner;
+module.exports = I18nTextScanner;

package/main/i18ntk-sizing.js

@@ -82,9 +82,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 +492,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 +564,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 +762,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 +1024,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
@@ -1018,6 +1201,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 +1258,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 +1294,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 +1317,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) {