i18ntk 1.10.2 → 2.0.2

package/main/i18ntk-complete.js

@@ -11,7 +11,7 @@
  *   node i18ntk-complete.js --source-dir=./src/i18n/locales
  */
 
-const fs = require('fs');
+
 const path = require('path');
 const SecurityUtils = require('../utils/security');
 const { getUnifiedConfig, parseCommonArgs, displayHelp } = require('../utils/config-helper');
@@ -19,21 +19,25 @@ const { loadTranslations, t } = require('../utils/i18n-helper');
 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) {
+// Ensure setup is complete before running, except for help output.
+(async () => {
+  const isHelpRequest = process.argv.slice(2).some(arg => arg === '--help' || arg === '-h');
+  if (isHelpRequest) {
+    return;
+  }
+  try {
+    await SetupEnforcer.checkSetupCompleteAsync();
+  } catch (error) {
     console.error('Setup check failed:', error.message);
     process.exit(1);
   }
 })();
 
-loadTranslations(process.env.I18NTK_LANG);
+loadTranslations();
 
 
 
-class I18nCompletionTool {
+class I18nCompletionTool {
   constructor(config = {}) {
     this.config = config;
     this.sourceDir = null;
@@ -105,46 +109,67 @@ class I18nCompletionTool {
           parsed.autoTranslate = true;
         } else if (key === 'dry-run') {
           parsed.dryRun = true;
-        } else if (key === 'no-prompt') {
-          parsed.noPrompt = true;
-        }
-      }
-    });
+        } else if (key === 'no-prompt') {
+          parsed.noPrompt = true;
+        } else if (key === 'help' || key === 'h') {
+          parsed.help = true;
+        }
+      }
+    });
     
     return parsed;
   }
 
-  // Get all available languages
-  getAvailableLanguages() {
-    if (!fs.existsSync(this.sourceDir)) {
+  // Get all available languages
+  getAvailableLanguages() {
+    if (!SecurityUtils.safeExistsSync(this.sourceDir, this.config.projectRoot)) {
       throw new Error(`Source directory not found: ${this.sourceDir}`);
     }
     
     // Check for monolith JSON files (en.json, es.json, etc.)
-    const files = fs.readdirSync(this.sourceDir);
-    const languages = files
-      .filter(file => file.endsWith('.json'))
-      .map(file => path.basename(file, '.json'));
-    
-    // Also check for directory-based structure for backward compatibility
-    const directories = fs.readdirSync(this.sourceDir)
-      .filter(item => {
-        const itemPath = path.join(this.sourceDir, item);
-        return fs.statSync(itemPath).isDirectory();
-      });
-    
-    return [...new Set([...languages, ...directories])];
-  }
+    const files = SecurityUtils.safeReaddirSync(this.sourceDir, this.config.projectRoot);
+    const languagesFromFiles = files
+      .filter(file => file.endsWith('.json'))
+      .map(file => path.basename(file, '.json'))
+      .filter(code => this.isValidLanguageCode(code));
+    
+    // Also check for directory-based structure for backward compatibility
+    const directories = SecurityUtils.safeReaddirSync(this.sourceDir, this.config.projectRoot)
+      .filter(item => {
+        if (this.isExcludedLanguageDirectory(item)) return false;
+        if (!this.isValidLanguageCode(item)) return false;
+        const itemPath = path.join(this.sourceDir, item);
+        const stat = SecurityUtils.safeStatSync(itemPath, this.config.projectRoot);
+        if (!stat || !stat.isDirectory()) return false;
+
+        const localeFiles = SecurityUtils.safeReaddirSync(itemPath, this.config.projectRoot)
+          .filter(name => name.endsWith('.json'));
+        return localeFiles.length > 0;
+      });
+    
+    return [...new Set([...languagesFromFiles, ...directories])];
+  }
+
+  isValidLanguageCode(code) {
+    if (!code || typeof code !== 'string') return false;
+    return /^[a-z]{2}(?:-[A-Za-z0-9]{2,8})*$/i.test(code.trim());
+  }
+
+  isExcludedLanguageDirectory(name) {
+    if (!name || typeof name !== 'string') return true;
+    const lowered = name.toLowerCase();
+    return lowered.startsWith('backup-') || lowered === 'backup' || lowered === 'reports' || lowered === 'i18ntk-reports';
+  }
 
   // Get all JSON files from a language directory
   getLanguageFiles(language) {
     const languageDir = path.join(this.sourceDir, language);
     
-    if (!fs.existsSync(languageDir)) {
+    if (!SecurityUtils.safeExistsSync(languageDir, this.config.projectRoot)) {
       return [];
     }
     
-    return fs.readdirSync(languageDir)
+    return SecurityUtils.safeReaddirSync(languageDir, this.config.projectRoot)
       .filter(file => {
         return file.endsWith('.json') && 
                !this.config.excludeFiles.includes(file);
@@ -234,18 +259,18 @@ class I18nCompletionTool {
       let fileContent = {};
       
       // Load existing file or create new
-      if (fs.existsSync(filePath)) {
+      if (SecurityUtils.safeExistsSync(filePath, this.config.projectRoot)) {
         try {
-          fileContent = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+          fileContent = JSON.parse(SecurityUtils.safeReadFileSync(filePath, this.config.projectRoot, 'utf8'));
         } catch (error) {
           console.warn(t("completeTranslations.warning_could_not_parse_filepa", { filePath })); ;
           fileContent = {};
         }
       } else {
         // Create directory if it doesn't exist
-        if (!fs.existsSync(languageDir)) {
+        if (!SecurityUtils.safeExistsSync(languageDir, this.config.projectRoot)) {
           if (!dryRun) {
-            fs.mkdirSync(languageDir, { recursive: true });
+            SecurityUtils.safeMkdirSync(languageDir, this.config.projectRoot, { recursive: true });
           }
         }
       }
@@ -271,7 +296,7 @@ class I18nCompletionTool {
       
       // Save file
       if (fileChanged && !dryRun) {
-        fs.writeFileSync(filePath, JSON.stringify(fileContent, null, 2), 'utf8');
+        SecurityUtils.safeWriteFileSync(filePath, JSON.stringify(fileContent, null, 2), this.config.projectRoot, 'utf8');
       }
     }
     
@@ -330,7 +355,7 @@ class I18nCompletionTool {
     const sourceFiles = this.getLanguageFiles(this.config.sourceLanguage);
     const missingKeys = [];
     
-    if (!fs.existsSync(this.sourceLanguageDir)) {
+    if (!SecurityUtils.safeExistsSync(this.sourceLanguageDir, this.config.projectRoot)) {
       console.log(t("complete.sourceLanguageNotFound", { sourceLanguage: this.config.sourceLanguage }));
       return [];
     }
@@ -340,7 +365,7 @@ class I18nCompletionTool {
       const sourceFilePath = path.join(this.sourceLanguageDir, fileName);
       
       try {
-        const sourceContent = JSON.parse(fs.readFileSync(sourceFilePath, 'utf8'));
+        const sourceContent = SecurityUtils.safeParseJSON(SecurityUtils.safeReadFileSync(sourceFilePath, this.config.projectRoot, 'utf8'));
         const sourceKeys = this.getAllKeys(sourceContent);
         
         // Check all other languages
@@ -351,9 +376,9 @@ class I18nCompletionTool {
           const targetFilePath = path.join(this.sourceDir, language, fileName);
           let targetKeys = [];
           
-          if (fs.existsSync(targetFilePath)) {
+          if (SecurityUtils.safeExistsSync(targetFilePath, this.config.projectRoot)) {
             try {
-              const targetContent = JSON.parse(fs.readFileSync(targetFilePath, 'utf8'));
+              const targetContent = SecurityUtils.safeParseJSON(SecurityUtils.safeReadFileSync(targetFilePath, this.config.projectRoot, 'utf8'));
               targetKeys = this.getAllKeys(targetContent);
             } catch (error) {
               console.warn(t("complete.couldNotParseTarget", { file: targetFilePath }));
@@ -379,8 +404,8 @@ class I18nCompletionTool {
   async generateReport(changes, languages) {
     const projectRoot = this.config.projectRoot || process.cwd();
     const reportsDir = path.join(projectRoot, 'i18ntk-reports');
-    if (!fs.existsSync(reportsDir)) {
-      fs.mkdirSync(reportsDir, { recursive: true });
+    if (!SecurityUtils.safeExistsSync(reportsDir, projectRoot)) {
+      SecurityUtils.safeMkdirSync(reportsDir, projectRoot, { recursive: true });
     }
     
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
@@ -407,7 +432,7 @@ class I18nCompletionTool {
       }))
     };
     
-    fs.writeFileSync(reportPath, JSON.stringify(report, null, 2), 'utf8');
+    SecurityUtils.safeWriteFileSync(reportPath, JSON.stringify(report, null, 2), projectRoot, 'utf8');
     console.log(t("complete.reportGenerated", { path: reportPath }));
     return reportPath;
   }
@@ -456,7 +481,7 @@ class I18nCompletionTool {
       this.config = { ...baseConfig, ...(this.config || {}) };
       
       const uiLanguage = (this.config && this.config.uiLanguage) || 'en';
-      loadTranslations(uiLanguage, path.resolve(__dirname, '..', 'ui-locales'));this.sourceDir = this.config.sourceDir;
+      loadTranslations(uiLanguage, path.resolve(__dirname, '..', 'resources', 'i18n', 'ui-locales'));this.sourceDir = this.config.sourceDir;
       this.sourceLanguageDir = path.join(this.sourceDir, this.config.sourceLanguage);
     } else {
       await this.initialize();
@@ -527,28 +552,28 @@ class I18nCompletionTool {
       console.log(t("complete.languagesProcessed", { languagesProcessed: languages.length }));
       console.log(t("complete.missingKeysAdded", { missingKeysAdded: missingKeys.length }));
       
-      if (!args.dryRun && allChanges.length > 0) {
-        const rl = this.rl || this.initReadline();
-        const answer = await this.prompt('\n' + t('complete.generateReportPrompt') + ' (Y/N): ');
-        
-        if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
-          await this.generateReport(allChanges, languages);
+      if (!args.dryRun && allChanges.length > 0 && !args.noPrompt) {
+        const rl = this.rl || this.initReadline();
+        const answer = await this.prompt('\n' + t('complete.generateReportPrompt') + ' (Y/N): ');
+        
+        if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+          await this.generateReport(allChanges, languages);
         }
       }
       
-      if (!args.dryRun) {
-        console.log('\n' + t("complete.nextStepsTitle"));
-        console.log(t("complete.separator"));
-        console.log(t("complete.nextStep1"));
-        console.log('   node i18ntk-usage.js --output-report');
-        console.log(t("complete.nextStep2"));
-        console.log('   node i18ntk-validate.js');
-        console.log(t("complete.nextStep3"));
-        console.log('   node i18ntk-analyze.js');
-        console.log('\n' + t("complete.allKeysAvailable"));
-      } else {
-        console.log('\n' + t("complete.runWithoutDryRun"));
-      }
+      if (!args.dryRun) {
+        console.log('\n' + t("complete.nextStepsTitle"));
+        console.log(t("complete.separator"));
+        console.log('1. Run usage analysis:');
+        console.log('   i18ntk --command=usage');
+        console.log('2. Validate translations:');
+        console.log('   i18ntk --command=validate');
+        console.log('3. Analyze translation status:');
+        console.log('   i18ntk --command=analyze');
+        console.log('\n' + t("complete.allKeysAvailable"));
+      } else {
+        console.log('\n' + t("complete.runWithoutDryRun"));
+      }
       
       // Only prompt when run from the menu (i.e., when a callback or menu context is present)
       if (typeof this.prompt === "function" && args.fromMenu) {
@@ -580,4 +605,4 @@ if (require.main === module) {
   });
 }
 
-module.exports = I18nCompletionTool;
+module.exports = I18nCompletionTool;

package/main/i18ntk-doctor.js

@@ -1,18 +1,21 @@
 #!/usr/bin/env node
+const SecurityUtils = require('../utils/security');
 const fs = require('fs');
 const path = require('path');
 const { getUnifiedConfig, parseCommonArgs, displayHelp } = require('../utils/config-helper');
 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 for standalone execution)
+if (require.main === module) {
+  (async () => {
+    try {
+      await SetupEnforcer.checkSetupCompleteAsync();
+    } catch (error) {
+      console.error('Setup check failed:', error.message);
+      process.exit(1);
+    }
+  })();
+}
 
 const ExitCodes = require('../utils/exit-codes');
 
@@ -50,115 +53,132 @@ function compareTypes(src, tgt, prefix = '', issues = []) {
   return issues;
 }
 
-(async () => {
-  const args = parseCommonArgs(process.argv.slice(2));
-  if (args.help) {
-    displayHelp('i18ntk-doctor');
-    process.exit(0);
-  }
-  const config = await getUnifiedConfig('doctor', args);
-  const dirs = {
-    projectRoot: config.projectRoot,
-    sourceDir: config.sourceDir,
-    i18nDir: config.i18nDir,
-    outputDir: config.outputDir,
-  };
-  
-  let exitCode = ExitCodes.SUCCESS;
-  const issues = [];
-
-  console.log('i18ntk doctor');
-  for (const [name, dir] of Object.entries(dirs)) {
-    const rel = path.relative(config.projectRoot, dir);
-    if (rel.startsWith('..') || path.isAbsolute(rel)) {
-      issues.push(`path traversal detected: ${dir}`);
-      exitCode = Math.max(exitCode, ExitCodes.SECURITY_VIOLATION);
-      continue;
-    }
-    const exists = fs.existsSync(dir);
-    console.log(`${name}: ${dir} ${exists ? '✅' : '❌'}`);
-    if (!exists) {
-      if (name !== 'outputDir') {
-        issues.push(`Missing directory: ${dir}`);
-        exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
-      }
-      continue;
-    }
-    try {
-      fs.accessSync(dir, fs.constants.R_OK | fs.constants.W_OK);
-    } catch (e) {
-      issues.push(`Permission issue: ${dir}`);
-      exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
+// Export the I18nDoctor class for module usage
+class I18nDoctor {
+  async run(options = {}) {
+    const args = parseCommonArgs(process.argv.slice(2));
+    if (args.help) {
+      displayHelp('i18ntk-doctor');
+      process.exit(0);
     }
-  }
-
-  const pkgVersion = require('../package.json').version;
-  if (config.version && config.version !== pkgVersion) {
-    issues.push(`Config version mismatch: ${config.version} != ${pkgVersion}`);
-    exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
-  }
+    const config = await getUnifiedConfig('doctor', args);
+    const dirs = {
+      projectRoot: config.projectRoot,
+      sourceDir: config.sourceDir,
+      i18nDir: config.i18nDir,
+      outputDir: config.outputDir,
+    };
 
-  const sourceLang = config.sourceLanguage || 'en';
-  const languages = config.defaultLanguages || [];
-  const srcDir = path.join(config.i18nDir, sourceLang);
-  const srcFiles = fs.existsSync(srcDir) ? fs.readdirSync(srcDir).filter(f => f.endsWith('.json')) : [];
+    let exitCode = ExitCodes.SUCCESS;
+    const issues = [];
 
-  for (const lang of languages) {
-    const langDir = path.join(config.i18nDir, lang);
-    if (!fs.existsSync(langDir)) {
-      issues.push(`Missing locale directory: ${lang}`);
-      exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
-      continue;
-    }
-    const files = fs.readdirSync(langDir).filter(f => f.endsWith('.json'));
-    for (const file of files) {
-      if (!srcFiles.includes(file)) {
-        issues.push(`Dangling namespace file: ${lang}/${file}`);
-        exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
+    console.log('i18ntk doctor');
+    for (const [name, dir] of Object.entries(dirs)) {
+      const rel = path.relative(config.projectRoot, dir);
+      if (rel.startsWith('..') || path.isAbsolute(rel)) {
+        issues.push(`path traversal detected: ${dir}`);
+        exitCode = Math.max(exitCode, ExitCodes.SECURITY_VIOLATION);
+        continue;
       }
-      const srcPath = path.join(srcDir, file);
-      const tgtPath = path.join(langDir, file);
-      if (!fs.existsSync(srcPath) || !fs.existsSync(tgtPath)) continue;
-      const srcContent = fs.readFileSync(srcPath, 'utf8');
-      const tgtContent = fs.readFileSync(tgtPath, 'utf8');
-      if (hasBOM(srcContent) || hasBOM(tgtContent)) {
-        issues.push(`BOM detected in ${lang}/${file}`);
-        exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
+      const exists = SecurityUtils.safeExistsSync(dir);
+      console.log(`${name}: ${dir} ${exists ? '✅' : '❌'}`);
+      if (!exists) {
+        if (name !== 'outputDir') {
+          issues.push(`Missing directory: ${dir}`);
+          exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
+        }
+        continue;
       }
-      let srcJson, tgtJson;
       try {
-        srcJson = JSON.parse(srcContent.replace(/^\uFEFF/, ''));
+        fs.accessSync(dir, fs.constants.R_OK | fs.constants.W_OK);
       } catch (e) {
-        issues.push(`Invalid JSON in source ${file}: ${e.message}`);
+        issues.push(`Permission issue: ${dir}`);
         exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
-        continue;
       }
-      try {
-        tgtJson = JSON.parse(tgtContent.replace(/^\uFEFF/, ''));
-      } catch (e) {
-        issues.push(`Invalid JSON in ${lang}/${file}: ${e.message}`);
+    }
+
+    const pkgVersion = require('../package.json').version;
+    if (config.version && config.version !== pkgVersion) {
+      issues.push(`Config version mismatch: ${config.version} != ${pkgVersion}`);
+      exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
+    }
+
+    const sourceLang = config.sourceLanguage || 'en';
+    const languages = config.defaultLanguages || [];
+    const srcDir = path.join(config.i18nDir, sourceLang);
+    const srcFiles = SecurityUtils.safeExistsSync(srcDir) ? fs.readdirSync(srcDir).filter(f => f.endsWith('.json')) : [];
+
+    for (const lang of languages) {
+      const langDir = path.join(config.i18nDir, lang);
+      if (!SecurityUtils.safeExistsSync(langDir)) {
+        issues.push(`Missing locale directory: ${lang}`);
         exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
         continue;
       }
-      const srcPlurals = collectPluralKeys(srcJson);
-      const tgtPlurals = collectPluralKeys(tgtJson);
-      for (const key of srcPlurals) {
-        if (!tgtPlurals.has(key)) {
-          issues.push(`Inconsistent plural forms in ${lang}/${file}: missing ${key}`);
+      const files = fs.readdirSync(langDir).filter(f => f.endsWith('.json'));
+      for (const file of files) {
+        if (!srcFiles.includes(file)) {
+          issues.push(`Dangling namespace file: ${lang}/${file}`);
+          exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
+        }
+        const srcPath = path.join(srcDir, file);
+        const tgtPath = path.join(langDir, file);
+        if (!SecurityUtils.safeExistsSync(srcPath) || !SecurityUtils.safeExistsSync(tgtPath)) continue;
+        const srcContent = SecurityUtils.safeReadFileSync(srcPath, path.dirname(srcPath), 'utf8');
+        const tgtContent = SecurityUtils.safeReadFileSync(tgtPath, path.dirname(tgtPath), 'utf8');
+        if (hasBOM(srcContent) || hasBOM(tgtContent)) {
+          issues.push(`BOM detected in ${lang}/${file}`);
+          exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
+        }
+        let srcJson, tgtJson;
+        try {
+          srcJson = JSON.parse(srcContent.replace(/^\uFEFF/, ''));
+        } catch (e) {
+          issues.push(`Invalid JSON in source ${file}: ${e.message}`);
           exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
+          continue;
         }
+        try {
+          tgtJson = JSON.parse(tgtContent.replace(/^\uFEFF/, ''));
+        } catch (e) {
+          issues.push(`Invalid JSON in ${lang}/${file}: ${e.message}`);
+          exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
+          continue;
+        }
+        const srcPlurals = collectPluralKeys(srcJson);
+        const tgtPlurals = collectPluralKeys(tgtJson);
+        for (const key of srcPlurals) {
+          if (!tgtPlurals.has(key)) {
+            issues.push(`Inconsistent plural forms in ${lang}/${file}: missing ${key}`);
+            exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
+          }
+        }
+        const typeMismatches = compareTypes(srcJson, tgtJson);
+        typeMismatches.forEach(k => {
+          issues.push(`Type mismatch for key ${k} in ${lang}/${file}`);
+          exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
+        });
       }
-      const typeMismatches = compareTypes(srcJson, tgtJson);
-      typeMismatches.forEach(k => {
-        issues.push(`Type mismatch for key ${k} in ${lang}/${file}`);
-        exitCode = Math.max(exitCode, ExitCodes.CONFIG_ERROR);
-      });
     }
-  }
 
-  if (issues.length > 0) {
-    console.log('\nIssues found:');
-    issues.forEach(i => console.log(` - ${i}`));
+    if (issues.length > 0) {
+      console.log('\nIssues found:');
+      issues.forEach(i => console.log(` - ${i}`));
+    }
+    
+    // Return the result instead of exiting for modular usage
+    if (require.main === module) {
+      process.exit(exitCode);
+    }
+    
+    return { success: exitCode === ExitCodes.SUCCESS, issues, exitCode };
   }
-  process.exit(exitCode);
-})();
+}
+
+// Only run as standalone script if called directly
+if (require.main === module) {
+  const doctor = new I18nDoctor();
+  doctor.run();
+}
+
+module.exports = I18nDoctor;