i18ntk 1.10.1 → 2.0.2

package/main/i18ntk-analyze.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 /**
  * I18NTK TRANSLATION ANALYSIS SCRIPT
  * 
@@ -7,7 +7,6 @@
  * 
  */
 
-const fs = require('fs');
 const path = require('path');
 const cliHelper = require('../utils/cli-helper');
 const { loadTranslations, t } = require('../utils/i18n-helper');
@@ -28,7 +27,7 @@ const SetupEnforcer = require('../utils/setup-enforcer');
   }
 })();
 
-loadTranslations( 'en', path.resolve(__dirname, '..', 'ui-locales'));
+loadTranslations( 'en', path.resolve(__dirname, '..', 'resources', 'i18n', 'ui-locales'));
 
 const PROJECT_ROOT = process.cwd();
 
@@ -68,7 +67,7 @@ class I18nAnalyzer {
       this.config = { ...baseConfig, ...(this.config || {}) };
       
       const uiLanguage = (this.config && this.config.uiLanguage) || 'en';
-      loadTranslations(uiLanguage, path.resolve(__dirname, '..', 'ui-locales'));
+      loadTranslations(uiLanguage, path.resolve(__dirname, '..', 'resources', 'i18n', 'ui-locales'));
       
       this.sourceDir = this.config.sourceDir;
       this.sourceLanguageDir = path.join(this.sourceDir, this.config.sourceLanguage);
@@ -146,7 +145,12 @@ class I18nAnalyzer {
   // Get all available languages
   getAvailableLanguages() {
     try {
-      const items = fs.readdirSync(this.sourceDir, { withFileTypes: true });
+      const items = SecurityUtils.safeReaddirSync(this.sourceDir, process.cwd(), { withFileTypes: true });
+      if (!items) {
+        console.error('Error reading source directory: Unable to access directory');
+        return [];
+      }
+      
       const languages = [];
       
       // Check for directory-based structure
@@ -173,15 +177,17 @@ class I18nAnalyzer {
       for (const dir of directories) {
         const dirPath = path.join(this.sourceDir, dir);
         try {
-          const dirItems = fs.readdirSync(dirPath, { withFileTypes: true });
-          const jsonFiles = dirItems
-            .filter(item => item.isFile() && item.name.endsWith('.json'))
-            .map(item => item.name.replace('.json', ''));
-          
-          // If directory contains JSON files, it's likely a language directory
-          if (jsonFiles.length > 0) {
-            if (!languages.includes(dir)) {
-              languages.push(dir);
+          const dirItems = SecurityUtils.safeReaddirSync(dirPath, process.cwd(), { withFileTypes: true });
+          if (dirItems) {
+            const jsonFiles = dirItems
+              .filter(item => item.isFile() && item.name.endsWith('.json'))
+              .map(item => item.name.replace('.json', ''));
+            
+            // If directory contains JSON files, it's likely a language directory
+            if (jsonFiles.length > 0) {
+              if (!languages.includes(dir)) {
+                languages.push(dir);
+              }
             }
           }
         } catch (error) {
@@ -208,12 +214,14 @@ class I18nAnalyzer {
     const files = [];
     
     // Handle monolith file structure
-    if (fs.existsSync(languageFile) && fs.statSync(languageFile).isFile()) {
+    const languageFileStat = SecurityUtils.safeStatSync(languageFile, this.sourceDir);
+    if (languageFileStat && languageFileStat.isFile()) {
       return [path.basename(languageFile)];
     }
     
     // Handle directory-based structure
-    if (fs.existsSync(languageDir) && fs.statSync(languageDir).isDirectory()) {
+    const languageDirStat = SecurityUtils.safeStatSync(languageDir, this.sourceDir);
+    if (languageDirStat && languageDirStat.isDirectory()) {
       try {
         // Ensure the path is within the source directory for security
         const validatedPath = SecurityUtils.validatePath(languageDir, this.sourceDir);
@@ -224,7 +232,9 @@ class I18nAnalyzer {
         
         const findJsonFiles = (dir) => {
           const results = [];
-          const items = fs.readdirSync(dir, { withFileTypes: true });
+          const items = SecurityUtils.safeReaddirSync(dir, this.sourceDir, { withFileTypes: true });
+          
+          if (!items) return results;
           
           for (const item of items) {
             const fullPath = path.join(dir, item.name);
@@ -267,16 +277,20 @@ class I18nAnalyzer {
       const searchDir = this.sourceDir;
       
       try {
-        if (fs.existsSync(searchDir)) {
-          const items = fs.readdirSync(searchDir, { withFileTypes: true });
+        const searchDirExists = SecurityUtils.safeExistsSync(searchDir, this.sourceDir);
+        if (searchDirExists) {
+          const items = SecurityUtils.safeReaddirSync(searchDir, this.sourceDir, { withFileTypes: true });
           
-          for (const item of items) {
-            if (item.isDirectory() && !item.name.startsWith('.') && item.name !== 'node_modules') {
-              const namespaceDir = path.join(searchDir, item.name);
-              const namespaceFile = path.join(namespaceDir, `${language}.json`);
-              
-              if (fs.existsSync(namespaceFile)) {
-                results.push(path.relative(path.join(this.sourceDir, item.name), namespaceFile));
+          if (items) {
+            for (const item of items) {
+              if (item.isDirectory() && !item.name.startsWith('.') && item.name !== 'node_modules') {
+                const namespaceDir = path.join(searchDir, item.name);
+                const namespaceFile = path.join(namespaceDir, `${language}.json`);
+                
+                const namespaceFileExists = SecurityUtils.safeExistsSync(namespaceFile, this.sourceDir);
+                if (namespaceFileExists) {
+                  results.push(path.relative(path.join(this.sourceDir, item.name), namespaceFile));
+                }
               }
             }
           }
@@ -468,15 +482,28 @@ class I18nAnalyzer {
       const sourceFullPath = path.join(this.sourceDir, sourceFilePath);
       const targetFullPath = path.join(this.sourceDir, targetFilePath);
       
-      if (!fs.existsSync(sourceFullPath)) {
+      const sourceExists = SecurityUtils.safeExistsSync(sourceFullPath, this.sourceDir);
+      if (!sourceExists) {
         continue;
       }
       
       let sourceContent, targetContent;
       
       try {
-        const sourceFileContent = fs.readFileSync(sourceFullPath, 'utf8');
-        sourceContent = JSON.parse(sourceFileContent);
+        const sourceFileContent = SecurityUtils.safeReadFileSync(sourceFullPath, this.sourceDir, 'utf8');
+        if (!sourceFileContent) {
+          analysis.files[fileName] = {
+            error: `Failed to read source file: File not accessible or empty`
+          };
+          continue;
+        }
+        sourceContent = SecurityUtils.safeParseJSON(sourceFileContent);
+        if (!sourceContent) {
+          analysis.files[fileName] = {
+            error: `Failed to parse source file: Invalid JSON format`
+          };
+          continue;
+        }
       } catch (error) {
         analysis.files[fileName] = {
           error: `Failed to parse source file: ${error.message}`
@@ -484,7 +511,8 @@ class I18nAnalyzer {
         continue;
       }
       
-      if (!fs.existsSync(targetFullPath)) {
+      const targetExists = SecurityUtils.safeExistsSync(targetFullPath, this.sourceDir);
+      if (!targetExists) {
         analysis.files[fileName] = {
           status: 'missing',
           sourceKeys: this.getAllKeys(sourceContent).size
@@ -493,9 +521,15 @@ class I18nAnalyzer {
       }
       
 try {
-    const targetFileContent = fs.readFileSync(targetFullPath, 'utf8');
-    const parsed = JSON.parse(targetFileContent);
-
+    const targetFileContent = SecurityUtils.safeReadFileSync(targetFullPath, this.sourceDir, 'utf8');
+    if (!targetFileContent) {
+      analysis.files[fileName] = {
+        error: `Failed to read target file: File not accessible or empty`
+      };
+      continue;
+    }
+    
+    const parsed = SecurityUtils.safeParseJSON(targetFileContent);
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
       analysis.files[fileName] = {
         error: `Invalid structure in target file: must be a plain object (not array/null/type)`
@@ -644,13 +678,10 @@ try {
       }
       
       // Ensure the output directory exists
-      try {
-        fs.mkdirSync(this.outputDir, { recursive: true });
-      } catch (error) {
-        if (error.code !== 'EEXIST') {
-          console.error(`Failed to create output directory ${this.outputDir}:`, error.message);
-          return null;
-        }
+      const dirCreated = SecurityUtils.safeMkdirSync(this.outputDir, process.cwd(), { recursive: true });
+      if (!dirCreated) {
+        console.error(`Failed to create output directory ${this.outputDir}`);
+        return null;
       }
       
       // Validate the output directory is within the project
@@ -670,14 +701,10 @@ try {
         return null;
       }
       
-      // Use safeWriteFile if available, otherwise fall back to writeFileSync
-      if (SecurityUtils.safeWriteFile) {
-        const success = await SecurityUtils.safeWriteFile(reportPath, report, this.outputDir);
-        if (!success) {
-          throw new Error(t('analyze.failedToWriteReportFile') || 'Failed to write report file securely');
-        }
-      } else {
-        fs.writeFileSync(reportPath, JSON.stringify(report, null, 2), 'utf8');
+      // Use safeWriteFile for secure file writing
+      const success = await SecurityUtils.safeWriteFile(reportPath, JSON.stringify(report, null, 2), process.cwd(), 'utf8');
+      if (!success) {
+        throw new Error(t('analyze.failedToWriteReportFile') || 'Failed to write report file securely');
       }
       
       console.log(`Report saved to: ${reportPath}`);
@@ -709,8 +736,9 @@ try {
       }
       
       // Ensure output directory exists
-      if (!fs.existsSync(this.outputDir)) {
-        fs.mkdirSync(this.outputDir, { recursive: true });
+      const outputDirExists = SecurityUtils.safeExistsSync(this.outputDir, process.cwd());
+      if (!outputDirExists) {
+        SecurityUtils.safeMkdirSync(this.outputDir, process.cwd(), { recursive: true });
       }
       
       const languages = this.getAvailableLanguages();
@@ -856,7 +884,7 @@ try {
         this.config = { ...baseConfig, ...this.config };
         
         const uiLanguage = this.config.uiLanguage || 'en';
-        loadTranslations(uiLanguage, path.resolve(__dirname, '..', 'ui-locales'));
+        loadTranslations(uiLanguage, path.resolve(__dirname, '..', 'resources', 'i18n', 'ui-locales'));
         
         this.sourceDir = this.config.sourceDir;
         this.sourceLanguageDir = path.join(this.sourceDir, this.config.sourceLanguage);
@@ -941,130 +969,110 @@ try {
   }
   
   async runSetupWizard() {
-    console.log('🧙‍♂️  Translation Analysis Setup Wizard');
+    console.log('Translation Analysis Setup Wizard');
     console.log('='.repeat(50));
-    
-    const prompts = require('prompts');
-    
+
     try {
-      // Detect current structure
       const structure = this.detectStructureType();
       console.log(`Current structure detected: ${structure.type}`);
-      
-      const questions = [
-        {
-          type: 'select',
-          name: 'structureType',
-          message: 'Choose your translation file structure:',
-          choices: [
-            { title: 'Monolith files (en.json, de.json, etc.)', value: 'monolith' },
-            { title: 'Directory structure (en/common.json, de/common.json)', value: 'directory' },
-            { title: 'Namespace structure (common/en.json, forms/en.json)', value: 'namespace' },
-            { title: 'Mixed structure (auto-detect)', value: 'mixed' }
-          ],
-          initial: structure.type === 'monolith' ? 0 : structure.type === 'directory' ? 1 : 2
-        },
-        {
-          type: 'text',
-          name: 'sourceDir',
-          message: 'Enter source directory path:',
-          initial: this.sourceDir,
-          validate: value => fs.existsSync(value) ? true : 'Directory does not exist'
-        },
-        {
-          type: 'text',
-          name: 'languages',
-          message: 'Enter languages to analyze (comma-separated, e.g., de,fr,es):',
-          initial: 'de,fr,es,ja,ru',
-          validate: value => value.trim() ? true : 'Please enter at least one language'
-        },
-        {
-          type: 'confirm',
-          name: 'outputReports',
-          message: 'Generate detailed reports for each language?',
-          initial: true
-        },
-        {
-          type: 'text',
-          name: 'outputDir',
-          message: 'Enter output directory for reports:',
-          initial: this.outputDir
-        }
-      ];
-      
-      const response = await prompts(questions);
-      
-      if (!response.structureType) {
-        console.log('Setup cancelled.');
+
+      const structureOptions = ['monolith', 'directory', 'namespace', 'mixed'];
+      const defaultStructureIndex = structureOptions.indexOf(structure.type);
+      const defaultStructureChoice = defaultStructureIndex >= 0 ? String(defaultStructureIndex + 1) : '4';
+
+      console.log('Choose your translation file structure:');
+      console.log('1) Monolith files (en.json, de.json, etc.)');
+      console.log('2) Directory structure (en/common.json, de/common.json)');
+      console.log('3) Namespace structure (common/en.json, forms/en.json)');
+      console.log('4) Mixed structure (auto-detect)');
+      const structureChoiceInput = await this.prompt(`Select option [${defaultStructureChoice}]: `);
+      const structureChoice = structureChoiceInput.trim() || defaultStructureChoice;
+      const structureType = structureOptions[Number(structureChoice) - 1] || 'mixed';
+
+      const sourceDirInput = await this.prompt(`Enter source directory path [${this.sourceDir}]: `);
+      const sourceDir = sourceDirInput.trim() || this.sourceDir;
+      if (!SecurityUtils.safeExistsSync(sourceDir, process.cwd())) {
+        console.log('Setup cancelled: directory does not exist.');
         return { success: false, cancelled: true };
       }
-      
-      // Update configuration
+
+      const languagesInput = await this.prompt('Enter languages to analyze (comma-separated) [de,fr,es,ja,ru]: ');
+      const languagesValue = languagesInput.trim() || 'de,fr,es,ja,ru';
+      const languages = languagesValue.split(',').map(lang => lang.trim()).filter(Boolean);
+      if (languages.length === 0) {
+        console.log('Setup cancelled: no languages provided.');
+        return { success: false, cancelled: true };
+      }
+
+      const outputReportsInput = await this.prompt('Generate detailed reports for each language? (Y/n): ');
+      const outputReports = !['n', 'no'].includes(outputReportsInput.trim().toLowerCase());
+
+      const outputDirInput = await this.prompt(`Enter output directory for reports [${this.outputDir}]: `);
+      const outputDir = outputDirInput.trim() || this.outputDir;
+
+      const response = {
+        structureType,
+        sourceDir,
+        languages: languagesValue,
+        outputReports,
+        outputDir
+      };
+
       this.sourceDir = path.resolve(response.sourceDir);
       this.outputDir = path.resolve(response.outputDir);
       this.outputReports = response.outputReports;
-      
-      const languages = response.languages.split(',').map(lang => lang.trim()).filter(Boolean);
-      
-      console.log('\n📊 Configuration Summary:');
+
+      console.log('\nConfiguration Summary:');
       console.log(`Source: ${this.sourceDir}`);
       console.log(`Output: ${this.outputDir}`);
-      console.log(`Languages: ${languages.join(', ')}`);
+      console.log(`Languages: ${languages.join(", ")}`);
       console.log(`Structure: ${response.structureType}`);
-      
-      const confirm = await prompts({
-        type: 'confirm',
-        name: 'proceed',
-        message: 'Proceed with analysis?',
-        initial: true
-      });
-      
-      if (!confirm.proceed) {
+
+      const proceedInput = await this.prompt('Proceed with analysis? (Y/n): ');
+      const proceed = !['n', 'no'].includes(proceedInput.trim().toLowerCase());
+      if (!proceed) {
         console.log('Setup cancelled.');
         return { success: false, cancelled: true };
       }
-      
-      // Run analysis with specified languages
+
       const results = [];
       for (const language of languages) {
         try {
-          console.log(`\n🔍 Analyzing ${language}...`);
+          console.log(`\nAnalyzing ${language}...`);
           const result = await this.analyzeLanguage(language);
           results.push({ language, ...result });
-          
+
           if (this.outputReports) {
             await this.saveReport(language, result);
-            console.log(`✅ Report saved: ${language}.json`);
+            console.log(`Report saved: ${language}.json`);
           }
         } catch (error) {
-          console.error(`❌ Error analyzing ${language}:`, error.message);
+          console.error(`Error analyzing ${language}:`, error.message);
           results.push({ language, error: error.message });
         }
       }
-      
-      // Generate summary
+
       const summary = {
         totalLanguages: results.length,
         successful: results.filter(r => !r.error).length,
         failed: results.filter(r => r.error).length,
         results
       };
-      
+
       await this.saveReport('wizard-summary', {
         summary,
         configuration: response,
         timestamp: new Date().toISOString()
       });
-      
-      console.log('\n🎉 Setup complete!');
+
+      console.log('\nSetup complete.');
       console.log(`Analyzed ${summary.successful}/${summary.totalLanguages} languages successfully`);
-      
+
       return {
         success: true,
         summary,
         configuration: response
       };
-      
     } catch (error) {
       console.error('Setup wizard error:', error.message);
       return { success: false, error: error.message };
@@ -1100,7 +1108,14 @@ async function analyzeTranslations(datasetPath) {
   analyzer.outputDir = './reports';
   
   // Load and analyze the dataset
-  const dataset = JSON.parse(fs.readFileSync(datasetPath, 'utf8'));
+  const datasetContent = SecurityUtils.safeReadFileSync(datasetPath, process.cwd(), 'utf8');
+  if (!datasetContent) {
+    throw new Error('Failed to load dataset for benchmark');
+  }
+  const dataset = SecurityUtils.safeParseJSON(datasetContent);
+  if (!dataset) {
+    throw new Error('Failed to parse dataset JSON');
+  }
   
   // Simulate analysis processing
   const languages = Object.keys(dataset).filter(lang => lang !== 'en');
@@ -1133,4 +1148,5 @@ async function analyzeTranslations(datasetPath) {
 module.exports = {
   I18nAnalyzer,
   analyzeTranslations
-};
+};
+