i18ntk 3.3.0 → 4.0.0

package/main/i18ntk-usage.js

@@ -84,6 +84,11 @@ class I18nUsageAnalyzer {
     this.startTime = Date.now(); // Track performance metrics
     this.version = '1.10.1'; // Version tracking
     
+    // Dead key detection properties
+    this.deadKeys = new Map();
+    this.cleanupMode = false;
+    this.dryRunDelete = false;
+    
     // Use global translation function
     this.rl = null;
   }
@@ -187,7 +192,9 @@ class I18nUsageAnalyzer {
       help: a.help || a.h,
       noPrompt: a.noPrompt ?? a['no-prompt'],
       strict: a.strict,
-      debug: a.debug
+      debug: a.debug,
+      cleanup: a.cleanup ?? a['cleanup'],
+      dryRunDelete: a.dryRunDelete ?? a['dry-run-delete']
     };
   }
 
@@ -376,6 +383,13 @@ class I18nUsageAnalyzer {
       console.log('🔍 Debug mode enabled');
     }
     
+    if (args.cleanup) {
+      this.cleanupMode = true;
+    }
+    if (args.dryRunDelete) {
+      this.dryRunDelete = true;
+    }
+    
     try {
       // Ensure config is always initialized
       if (!this.config) {
@@ -599,6 +613,33 @@ class I18nUsageAnalyzer {
         }));
       }
       
+      if (this.cleanupMode) {
+        const deadKeys = this.findDeadKeys();
+        console.log('\n' + t('usage.deadKeysDetectionTitle'));
+        console.log(t('usage.deadKeysCount', { count: deadKeys.length }));
+        
+        const highConfidence = deadKeys.filter(dk => dk.confidence >= 0.8).length;
+        const mediumConfidence = deadKeys.filter(dk => dk.confidence >= 0.4 && dk.confidence < 0.8).length;
+        const lowConfidence = deadKeys.filter(dk => dk.confidence < 0.4).length;
+        
+        console.log(t('usage.deadKeysConfidenceBreakdown', { high: highConfidence, medium: mediumConfidence, low: lowConfidence }));
+        
+        if (deadKeys.length > 0) {
+          console.log('\n' + t('usage.deadKeysSample'));
+          deadKeys.slice(0, 10).forEach(dk => {
+            console.log(`  ${dk.key} [${(dk.confidence * 100).toFixed(0)}%] - ${dk.reason}`);
+          });
+          if (deadKeys.length > 10) {
+            console.log(t('usage.deadKeysMore', { count: deadKeys.length - 10 }));
+          }
+        }
+        
+        if (this.dryRunDelete) {
+          const reportPath = this.saveDeadKeysReport(deadKeys, args.outputDir || this.config.outputDir || './i18ntk-reports/usage');
+          console.log(t('usage.deadKeysReportSaved', { path: reportPath }));
+        }
+      }
+      
       if (args.outputReport) {
         const report = this.generateUsageReport();
         await this.saveReport(report, args.outputDir);
@@ -625,7 +666,7 @@ class I18nUsageAnalyzer {
   // Show help message
   showHelp() {
     console.log(`
-📊 i18ntk usage - Translation key usage analysis (v1.8.3)
+📊 i18ntk usage - Translation key usage analysis (v1.10.1)
 
 Usage:
   node i18ntk-usage.js [options]
@@ -642,14 +683,17 @@ Options:
   --validate-placeholders Enable placeholder key validation
   --framework-detect     Enable framework-specific pattern detection
   --performance-mode     Enable performance metrics tracking
+  --cleanup              Enable dead key detection for cleanup mode
+  --dry-run-delete       Save dead keys report without deleting (requires --cleanup)
   --help, -h             Show this help message
 
 Examples:
   node i18ntk-usage.js --source-dir=./src --i18n-dir=./translations --output-report
   npm run i18ntk:usage -- --strict --debug --validate-placeholders
   node i18ntk-usage.js --no-prompt --performance-mode --output-dir=./reports
+  node i18ntk-usage.js --cleanup --dry-run-delete
 
-Analysis Features (v1.8.3):
+Analysis Features (v1.10.1):
   • Detects unused translation keys
   • Identifies missing translation keys
   • Shows translation completeness by language
@@ -662,6 +706,7 @@ Analysis Features (v1.8.3):
   • Key complexity analysis
   • Security-enhanced path validation
   • Detailed reporting with validation errors
+  • Dead key detection with confidence scoring
 `);
   }
 
@@ -1133,6 +1178,161 @@ Analysis Features (v1.8.3):
     return missing;
   }
 
+  findDeadKeys() {
+    const unusedKeys = this.findUnusedKeys();
+    const deadKeys = [];
+
+    for (const key of unusedKeys) {
+      let confidence = 0.9;
+      let reason = 'Key not found in any source file';
+
+      if (this._matchesDynamicPattern(key)) {
+        confidence = 0.3;
+        reason = 'Key matches dynamic template pattern (likely used)';
+      } else if (this._keyInSourceComments(key)) {
+        confidence = 0.5;
+        reason = 'Key referenced in comments/JSDoc';
+      } else if (this._parentFileRecentlyModified(key)) {
+        confidence = 0.4;
+        reason = 'Translation file modified within last 30 days';
+      }
+
+      deadKeys.push({ key, confidence, reason });
+    }
+
+    deadKeys.sort((a, b) => b.confidence - a.confidence);
+    return deadKeys;
+  }
+
+  _matchesDynamicPattern(key) {
+    const keyParts = key.split('.');
+    if (keyParts.length < 2) return false;
+
+    const dynamicPatterns = [
+      /t\(`[^`]*\$\{[^}]*\}[^`]*`\)/g,
+      /i18n\.t\(`[^`]*\$\{[^}]*\}[^`]*`\)/g,
+      /useTranslation\(\)\.t\(`[^`]*\$\{[^}]*\}[^`]*`\)/g
+    ];
+
+    try {
+      const sourceFiles = Array.from(this.fileUsage.keys());
+      for (const filePath of sourceFiles) {
+        const fullPath = path.join(this.sourceDir, filePath);
+        if (!SecurityUtils.safeExistsSync(fullPath, this.sourceDir)) continue;
+
+        const content = SecurityUtils.safeReadFileSync(fullPath, this.sourceDir, 'utf8');
+        if (!content) continue;
+
+        for (const pattern of dynamicPatterns) {
+          const matches = content.match(pattern);
+          if (matches) {
+            for (const match of matches) {
+              const matchLower = match.toLowerCase();
+              if (keyParts.some(part => matchLower.includes(part.toLowerCase()))) {
+                return true;
+              }
+            }
+          }
+        }
+      }
+    } catch (e) {
+      // Silently fail - dynamic pattern detection is best-effort
+    }
+
+    return false;
+  }
+
+  _keyInSourceComments(key) {
+    const commentPatterns = [
+      /\/\/[^\n]*/g,
+      /\/\*[\s\S]*?\*\//g,
+      /\/\*\*[\s\S]*?\*\//g
+    ];
+
+    try {
+      const sourceFiles = Array.from(this.fileUsage.keys());
+      for (const filePath of sourceFiles) {
+        const fullPath = path.join(this.sourceDir, filePath);
+        if (!SecurityUtils.safeExistsSync(fullPath, this.sourceDir)) continue;
+
+        const content = SecurityUtils.safeReadFileSync(fullPath, this.sourceDir, 'utf8');
+        if (!content) continue;
+
+        for (const pattern of commentPatterns) {
+          const comments = content.match(pattern);
+          if (comments) {
+            for (const comment of comments) {
+              if (comment.includes(key)) {
+                return true;
+              }
+            }
+          }
+        }
+      }
+    } catch (e) {
+      // Silently fail - comment detection is best-effort
+    }
+
+    return false;
+  }
+
+  _parentFileRecentlyModified(key) {
+    const thirtyDaysMs = 30 * 24 * 60 * 60 * 1000;
+    const now = Date.now();
+
+    try {
+      for (const [filePath] of this.translationFiles) {
+        if (!SecurityUtils.safeExistsSync(filePath, this.i18nDir)) continue;
+
+        const content = SecurityUtils.safeReadFileSync(filePath, this.i18nDir, 'utf8');
+        if (!content) continue;
+
+        if (content.includes(key)) {
+          const stats = SecurityUtils.safeStatSync(filePath, this.i18nDir);
+          if (stats && stats.mtime) {
+            const mtimeMs = new Date(stats.mtime).getTime();
+            if ((now - mtimeMs) <= thirtyDaysMs) {
+              return true;
+            }
+          }
+        }
+      }
+    } catch (e) {
+      // Silently fail - file stat is best-effort
+    }
+
+    return false;
+  }
+
+  generateDeadKeysReport(deadKeys) {
+    const allCleanupReady = deadKeys.length === 0 || deadKeys.every(dk => dk.confidence >= 0.8);
+
+    return {
+      deadKeys,
+      totalAvailableKeys: this.availableKeys.size,
+      totalUsedKeys: this.usedKeys.size,
+      deadKeyCount: deadKeys.length,
+      cleanupReady: allCleanupReady,
+      generatedAt: new Date().toISOString(),
+      version: this.version
+    };
+  }
+
+  saveDeadKeysReport(deadKeys, outputDir) {
+    const report = this.generateDeadKeysReport(deadKeys);
+    const resolvedDir = path.resolve(outputDir || './i18ntk-reports/usage');
+
+    if (!SecurityUtils.safeExistsSync(resolvedDir, process.cwd())) {
+      SecurityUtils.safeMkdirSync(resolvedDir, process.cwd(), { recursive: true });
+    }
+
+    const filename = '.dead-keys.json';
+    const filepath = path.join(resolvedDir, filename);
+
+    SecurityUtils.safeWriteFileSync(filepath, JSON.stringify(report, null, 2), resolvedDir, 'utf8');
+    return filepath;
+  }
+
   // Find files that use specific keys
   findKeyUsage(searchKey) {
     const usage = [];

package/main/i18ntk-validate.js

@@ -68,6 +68,7 @@ class I18nValidator {
     this.config = config;
     this.errors = [];
     this.warnings = [];
+    this.keyNamingViolations = [];
     this.rl = null;
   }
   
@@ -167,6 +168,8 @@ class I18nValidator {
           const key = sanitizedArg.substring(2);
           if (['en', 'de', 'es', 'fr', 'ru', 'ja', 'zh'].includes(key)) {
             baseArgs.uiLanguage = key;
+          } else if (key === 'enforce-key-style') {
+            baseArgs.enforceKeyStyle = true;
           }
         }
       });
@@ -573,6 +576,25 @@ class I18nValidator {
       // Validate structure
       const structural = this.validateStructure(sourceContent, targetContent, language, fileName);
       
+      // Check key naming conventions
+      if (this.config.enforceKeyStyle) {
+        const keyNamingResult = this.validateKeyNaming(sourceContent);
+        keyNamingResult.violations.forEach(v => {
+          this.addWarning(
+            `Key naming violation in ${language}/${fileName}`,
+            { key: v.key, suggestedFix: v.suggestedFix, reason: v.reason, style: keyNamingResult.style }
+          );
+          this.keyNamingViolations.push({
+            language,
+            fileName,
+            key: v.key,
+            suggestedFix: v.suggestedFix,
+            reason: v.reason,
+            style: keyNamingResult.style
+          });
+        });
+      }
+      
      // Validate translations
       const translations = this.validateTranslation(targetContent, language, fileName);
       this.checkPlaceholders(sourceContent, targetContent, language, fileName);
@@ -652,7 +674,68 @@ class I18nValidator {
     return warnings;
   }
 
-  // Show help message
+  validateKeyNaming(sourceObj, style) {
+    const keyStyle = style || this.config.keyStyle || 'dot.notation';
+    const allKeys = this.getAllKeys(sourceObj);
+    const validators = {
+      'dot.notation': /^[a-z][a-z0-9]*(\.[a-z][a-z0-9]*)*$/,
+      'snake_case': /^[a-z][a-z0-9]*(_[a-z][a-z0-9]*)*$/,
+      'camelCase': /^[a-z][a-zA-Z0-9]*$/,
+      'kebab-case': /^[a-z][a-z0-9]*(-[a-z][a-z0-9]*)*$/,
+      'flat': /^[a-zA-Z][a-zA-Z0-9]*$/
+    };
+    const regex = validators[keyStyle];
+    if (!regex) {
+      return { violations: [], totalKeys: allKeys.size, violationCount: 0, style: keyStyle };
+    }
+    const violations = [];
+    for (const key of allKeys) {
+      const sanitizedKey = SecurityUtils.sanitizeInput(key);
+      if (!regex.test(sanitizedKey)) {
+        violations.push({
+          key: sanitizedKey,
+          suggestedFix: this.suggestKeyFix(sanitizedKey, keyStyle),
+          reason: `Key "${sanitizedKey}" does not match "${keyStyle}" naming convention`
+        });
+      }
+    }
+    return {
+      violations,
+      totalKeys: allKeys.size,
+      violationCount: violations.length,
+      style: keyStyle
+    };
+  }
+
+  suggestKeyFix(key, style) {
+    const sanitizedKey = SecurityUtils.sanitizeInput(key);
+    const segments = [];
+    const rawTokens = sanitizedKey.split(/[._\-]/);
+    for (const token of rawTokens) {
+      if (!token) continue;
+      const camelTokens = token.split(/(?=[A-Z])/).filter(Boolean);
+      segments.push(...camelTokens);
+    }
+    if (segments.length === 0) {
+      return sanitizedKey;
+    }
+    switch (style) {
+      case 'dot.notation':
+        return segments.map(s => s.toLowerCase()).join('.');
+      case 'snake_case':
+        return segments.map(s => s.toLowerCase()).join('_');
+      case 'camelCase':
+        return segments.map((s, i) => i === 0 ? s.toLowerCase() : s.charAt(0).toUpperCase() + s.slice(1).toLowerCase()).join('');
+      case 'kebab-case':
+        return segments.map(s => s.toLowerCase()).join('-');
+      case 'flat':
+        return segments.map((s, i) => i === 0 ? s.toLowerCase() : s.charAt(0).toUpperCase() + s.slice(1).toLowerCase()).join('');
+      default:
+        return sanitizedKey;
+    }
+  }
+
+  // Show help message
   showHelp() {
     console.log(t('validate.help_message'));
   }
@@ -895,8 +978,29 @@ class I18nValidator {
           console.log('');
         });
       }
-      
-      // Recommendations
+
+      // Key naming violations summary
+      if (this.keyNamingViolations.length > 0) {
+        console.log('');
+        console.log(t('validate.separator'));
+        console.log('🔑 Key Naming Convention Violations');
+        console.log('');
+        const displayStyle = this.config.keyStyle || 'dot.notation';
+        console.log(`  Expected style: ${displayStyle}`);
+        console.log(`  Violations found: ${this.keyNamingViolations.length}`);
+        console.log('');
+        console.log('  Suggested fixes:');
+        this.keyNamingViolations.slice(0, 10).forEach((v, i) => {
+          console.log(`  ${i + 1}. "${v.key}" → "${v.suggestedFix}" (${v.language}/${v.fileName})`);
+        });
+        if (this.keyNamingViolations.length > 10) {
+          console.log(`  ... and ${this.keyNamingViolations.length - 10} more`);
+        }
+        console.log('');
+        console.log('  💡 Tip: Use i18ntk:fix-keys to auto-fix or manually rename keys.');
+      }
+
+      // Recommendations
       console.log('');
       console.log(t('validate.separator'));
       console.log(t('validate.recommendationsSection'));

package/main/manage/commands/FixerCommand.js

@@ -530,20 +530,20 @@ class FixerCommand {
             this.dryRun = args.dryRun || false;
             this.force = args.force || false;
 
-            if (!args.json) {
-                console.log(t('fixer.starting'));
-                console.log(t('fixer.sourceDirectory', { dir: path.resolve(this.sourceDir) }));
-                console.log(t('fixer.dryRunMode', { mode: this.dryRun ? 'ON' : 'OFF' }));
-            }
+            const languages = this.getAvailableLanguages();
+
+            if (!args.json) {
+                console.log(t('fixer.starting', { languages: languages.join(', ') || 'none' }));
+                console.log(t('fixer.sourceDirectory', { sourceDir: path.resolve(this.sourceDir) }));
+                console.log(t('fixer.dryRunMode', { mode: this.dryRun ? 'ON' : 'OFF' }));
+            }
 
             // Create backup unless disabled
             if (!args.noBackup && !this.dryRun && this.config?.backup?.enabled === true) {
                 await this.createBackup();
             }
 
-            const languages = this.getAvailableLanguages();
-
-            if (languages.length === 0) {
+            if (languages.length === 0) {
                 const error = t('fixer.noLanguages') || 'No target languages found.';
                 if (args.json) {
                     jsonOutput.setStatus('error', error);
@@ -573,14 +573,16 @@ class FixerCommand {
                 totalIssues += fixes.totalIssues;
                 totalFixed += fixes.fixedIssues;
 
-                if (!args.json) {
-                    console.log(t('fixer.languageFixed', {
-                        language,
-                        issues: fixes.totalIssues,
-                        fixed: fixes.fixedIssues
-                    }));
-                }
-            }
+                if (!args.json) {
+                    const skipped = Math.max(0, fixes.totalIssues - fixes.fixedIssues);
+                    console.log(t('fixer.languageFixed', {
+                        language,
+                        issues: fixes.totalIssues,
+                        fixed: fixes.fixedIssues,
+                        skipped
+                    }));
+                }
+            }
 
             // Prepare JSON output
             if (args.json) {
@@ -595,11 +597,11 @@ class FixerCommand {
                 return { success: true, totalIssues, totalFixed, results };
             }
 
-            // Summary
-            console.log(t('fixer.summary'));
-            console.log('='.repeat(50));
-            console.log(t('fixer.totalIssues', { count: totalIssues }));
-            console.log(t('fixer.totalFixed', { count: totalFixed }));
+            // Summary
+            console.log(t('fixer.summary'));
+            console.log('='.repeat(50));
+            console.log(t('fixer.totalIssues', { totalIssues }));
+            console.log(t('fixer.totalFixed', { count: totalFixed }));
 
             if (this.backupDir && !args.noBackup && this.config?.backup?.enabled === true) {
                 console.log(t('fixer.backupLocation', { dir: this.backupDir }));

package/main/manage/index.js

@@ -1220,7 +1220,10 @@ class I18nManager {
             { path: path.join(process.cwd(), 'scripts', 'debug', 'logs'), name: 'Debug Logs', type: 'logs' },
             { path: path.join(process.cwd(), 'scripts', 'debug', 'reports'), name: 'Debug Reports', type: 'reports' },
             { path: path.join(process.cwd(), 'settings', 'backups'), name: 'Settings Backups', type: 'backups' },
-            { path: path.join(process.cwd(), 'utils', 'i18ntk-reports'), name: 'Utils Reports', type: 'reports' }
+            { path: path.join(process.cwd(), 'utils', 'i18ntk-reports'), name: 'Utils Reports', type: 'reports' },
+            { path: path.join(process.cwd(), '.cache'), name: 'Cache', type: 'cache', includeAllFiles: true },
+            { path: path.join(process.cwd(), 'settings', '.cache'), name: 'Settings Cache', type: 'cache', includeAllFiles: true },
+            { path: path.join(process.cwd(), '.cache-ultra'), name: 'Performance Cache', type: 'cache', includeAllFiles: true }
         ].filter(dir => dir.path && typeof dir.path === 'string');
 
         try {
@@ -1233,7 +1236,9 @@ class I18nManager {
             for (const dir of targetDirs) {
                 const validatedDirPath = SecurityUtils.validatePath(dir.path, projectRoot);
                 if (validatedDirPath && SecurityUtils.safeExistsSync(validatedDirPath, projectRoot)) {
-                    const files = this.getAllReportFiles(validatedDirPath, validatedDirPath);
+                    const files = this.getAllReportFiles(validatedDirPath, validatedDirPath, {
+                        includeAllFiles: dir.includeAllFiles === true
+                    });
                     if (files.length > 0) {
                         availableDirs.push({
                             ...dir,
@@ -1368,12 +1373,13 @@ class I18nManager {
         await this.showInteractiveMenu();
     }
 
-    getAllReportFiles(dir, rootDir = dir) {
+    getAllReportFiles(dir, rootDir = dir, options = {}) {
         if (!dir || typeof dir !== 'string') {
             return [];
         }
 
-        let files = [];
+        let files = [];
+        const includeAllFiles = options.includeAllFiles === true;
 
         try {
             const validatedDir = SecurityUtils.validatePath(dir, rootDir);
@@ -1399,8 +1405,8 @@ class I18nManager {
                     const stat = fs.statSync(safeFullPath);
 
                     if (stat.isDirectory()) {
-                        files.push(...this.getAllReportFiles(safeFullPath, rootDir));
-                    } else if (
+                        files.push(...this.getAllReportFiles(safeFullPath, rootDir, options));
+                    } else if (includeAllFiles || (
                         // Common report file extensions
                         item.endsWith('.json') ||
                         item.endsWith('.html') ||
@@ -1415,7 +1421,7 @@ class I18nManager {
                         item.includes('report_') ||
                         item.includes('analysis-') ||
                         item.includes('validation-')
-                    ) {
+                    )) {
                         files.push(safeFullPath);
                     }
                 } catch (error) {

package/main/manage/services/FileManagementService.js

@@ -129,7 +129,10 @@ module.exports = class FileManagementService {
       { path: path.join(process.cwd(), 'scripts', 'debug', 'logs'), name: 'Debug Logs', type: 'logs' },
       { path: path.join(process.cwd(), 'scripts', 'debug', 'reports'), name: 'Debug Reports', type: 'reports' },
       { path: path.join(process.cwd(), 'settings', 'backups'), name: 'Settings Backups', type: 'backups' },
-      { path: path.join(process.cwd(), 'utils', 'i18ntk-reports'), name: 'Utils Reports', type: 'reports' }
+      { path: path.join(process.cwd(), 'utils', 'i18ntk-reports'), name: 'Utils Reports', type: 'reports' },
+      { path: path.join(process.cwd(), '.cache'), name: 'Cache', type: 'cache', includeAllFiles: true },
+      { path: path.join(process.cwd(), 'settings', '.cache'), name: 'Settings Cache', type: 'cache', includeAllFiles: true },
+      { path: path.join(process.cwd(), '.cache-ultra'), name: 'Performance Cache', type: 'cache', includeAllFiles: true }
     ].filter(dir => dir.path && typeof dir.path === 'string');
 
     try {
@@ -140,7 +143,9 @@ module.exports = class FileManagementService {
       // Check which directories exist and have files
       for (const dir of targetDirs) {
         if (SecurityUtils.safeExistsSync(dir.path)) {
-          const files = this.getAllReportFiles(dir.path);
+          const files = this.getAllReportFiles(dir.path, {
+            includeAllFiles: dir.includeAllFiles === true
+          });
           if (files.length > 0) {
             availableDirs.push({
               ...dir,
@@ -267,12 +272,13 @@ module.exports = class FileManagementService {
    * @param {string} dir - Directory to scan
    * @returns {string[]} Array of file paths
    */
-  getAllReportFiles(dir) {
+  getAllReportFiles(dir, options = {}) {
     if (!dir || typeof dir !== 'string') {
       return [];
     }
 
     let files = [];
+    const includeAllFiles = options.includeAllFiles === true;
 
     try {
       if (!SecurityUtils.safeExistsSync(dir)) {
@@ -287,8 +293,8 @@ module.exports = class FileManagementService {
           const stat = fs.statSync(fullPath);
 
           if (stat.isDirectory()) {
-            files.push(...this.getAllReportFiles(fullPath));
-          } else if (
+            files.push(...this.getAllReportFiles(fullPath, options));
+          } else if (includeAllFiles || (
             // Common report file extensions
             item.endsWith('.json') ||
             item.endsWith('.html') ||
@@ -303,7 +309,7 @@ module.exports = class FileManagementService {
             item.includes('report_') ||
             item.includes('analysis-') ||
             item.includes('validation-')
-          ) {
+          )) {
             files.push(fullPath);
           }
         } catch (error) {