i18ntk 1.10.2 → 2.0.3

package/utils/setup-enforcer.js

@@ -11,22 +11,43 @@ const { getIcon } = require('./terminal-icons');
 const fs = require('fs');
 const path = require('path');
 const { blue, yellow, gray, cyan, green, red } = require('./colors-new');
+const SecurityUtils = require('./security');
 
 class SetupEnforcer {
     static _setupCheckInProgress = false;
     static _setupCheckPromise = null;
 
-    static checkSetupComplete() {
-        const configManager = require('./config-manager');
-        const configPath = configManager.CONFIG_PATH;
-        
-        if (!fs.existsSync(configPath)) {
-            this.handleMissingSetup();
-            return;
+    /**
+     * Detect if running in non-interactive environment
+     * @returns {boolean} - True if non-interactive
+     */
+    static isNonInteractive() {
+        return !process.stdout.isTTY ||
+               !process.stdin.isTTY ||
+               process.env.CI === 'true' ||
+               process.env.CONTINUOUS_INTEGRATION === 'true' ||
+               process.env.NODE_ENV === 'test' ||
+               process.env.npm_lifecycle_event === 'test' ||
+               Boolean(process.env.NO_INTERACTIVE);
+    }
+
+    static checkSetupComplete() {
+         // Avoid circular dependency - use direct path resolution
+         const path = require('path');
+         const configPath = path.join(process.cwd(), '.i18ntk-config');
+        const exists = SecurityUtils.safeExistsSync(configPath);
+        if (!exists) {
+            this.handleMissingSetup();
+            return;
         }
 
         try {
-            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            const configRaw = SecurityUtils.safeReadFileSync(configPath, path.dirname(configPath), 'utf8');
+            const config = SecurityUtils.safeParseJSON(configRaw);
+            if (!config || typeof config !== 'object') {
+                this.handleInvalidConfig();
+                return;
+            }
             
             // Check if setup has been explicitly marked as completed
             if (config.setup && config.setup.completed === true) {
@@ -34,7 +55,7 @@ class SetupEnforcer {
             }
             
             // Fallback: check if config has required fields (for backward compatibility)
-            if (!config.version || !config.sourceDir || !config.detectedFramework) {
+            if (!config.version || !config.sourceDir || (!config.detectedFramework && !(config.framework && config.framework.detected !== false))) {
                 this.handleIncompleteSetup();
                 return;
             }
@@ -51,29 +72,47 @@ class SetupEnforcer {
         console.log(yellow('Welcome to i18n Toolkit! This appears to be your first time running the toolkit.'));
         console.log(gray('Setup is required to configure your project for internationalization management.'));
         console.log('');
-        
-        // Use readline for interactive prompt
+
+        // Check if running in non-interactive environment
+        if (SetupEnforcer.isNonInteractive()) {
+            console.log(yellow('⚠️  Non-interactive environment detected.'));
+            console.log(gray('Please run setup manually:'));
+            console.log(cyan('   npm run i18ntk-setup'));
+            console.log(gray('Or set NO_INTERACTIVE=false to force interactive mode.'));
+            process.exit(1);
+        }
+
+        // Use readline for interactive prompt with timeout
         const readline = require('readline');
         const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout
         });
-        
+
         return new Promise((resolve, reject) => {
+            // Set timeout for user input (30 seconds)
+            const timeout = setTimeout(() => {
+                console.log(yellow('\n⏰ Timeout reached - no response received.'));
+                console.log(gray('Setup cancelled. Run "npm run i18ntk-setup" when you\'re ready.'));
+                rl.close();
+                process.exit(1);
+            }, 30000); // 30 second timeout
+
             rl.question(cyan('Would you like to run setup now? (Y/n): '), async (answer) => {
+                clearTimeout(timeout);
                 rl.close();
-                
+
                 if (answer.toLowerCase() === 'n' || answer.toLowerCase() === 'no') {
                     console.log(gray('Setup cancelled. Run "npm run i18ntk-setup" when you\'re ready.'));
                     process.exit(0);
                 }
-                
+
                 console.log(green(`${getIcon('rocket')} Running setup...`));
-                
+
                 try {
                     // Import and run setup directly
                     const setupPath = path.join(__dirname, '..', 'main', 'i18ntk-setup.js');
-                    if (fs.existsSync(setupPath)) {
+                    if (SecurityUtils.safeExistsSync(setupPath)) {
                         try {
                             const setup = require(setupPath);
                             // Use the run function which properly instantiates the class
@@ -112,27 +151,45 @@ static async handleIncompleteSetup() {
         console.log(yellow('Your setup appears to be incomplete or outdated.'));
         console.log(gray('This might happen after updating to a new version.'));
         console.log('');
-        
+
+        // Check if running in non-interactive environment
+        if (SetupEnforcer.isNonInteractive()) {
+            console.log(yellow('⚠️  Non-interactive environment detected.'));
+            console.log(gray('Please run setup manually:'));
+            console.log(cyan('   npm run i18ntk-setup'));
+            console.log(gray('Or set NO_INTERACTIVE=false to force interactive mode.'));
+            process.exit(1);
+        }
+
         const readline = require('readline');
         const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout
         });
-        
+
         return new Promise((resolve, reject) => {
+            // Set timeout for user input (30 seconds)
+            const timeout = setTimeout(() => {
+                console.log(yellow('\n⏰ Timeout reached - no response received.'));
+                console.log(gray('Setup cancelled. Run "npm run i18ntk-setup" when you\'re ready.'));
+                rl.close();
+                process.exit(1);
+            }, 30000); // 30 second timeout
+
             rl.question(cyan('Would you like to re-run setup? (Y/n): '), async (answer) => {
+                clearTimeout(timeout);
                 rl.close();
-                
+
                 if (answer.toLowerCase() === 'n' || answer.toLowerCase() === 'no') {
                     console.log(gray('Operation cancelled.'));
                     process.exit(0);
                 }
-                
+
                 console.log(green(`${getIcon('rocket')} Running setup...`));
-                
+
                 try {
                     const setupPath = path.join(__dirname, '..', 'main', 'i18ntk-setup.js');
-                    if (fs.existsSync(setupPath)) {
+                    if (SecurityUtils.safeExistsSync(setupPath)) {
                         try {
                             const setup = require(setupPath);
                             // Use the run function which properly instantiates the class
@@ -169,27 +226,45 @@ static async handleInvalidConfig() {
         console.log(yellow('Your configuration file appears to be corrupted or invalid.'));
         console.log(gray('This might happen due to file corruption or manual editing.'));
         console.log('');
-        
+
+        // Check if running in non-interactive environment
+        if (SetupEnforcer.isNonInteractive()) {
+            console.log(yellow('⚠️  Non-interactive environment detected.'));
+            console.log(gray('Please run setup manually:'));
+            console.log(cyan('   npm run i18ntk-setup'));
+            console.log(gray('Or set NO_INTERACTIVE=false to force interactive mode.'));
+            process.exit(1);
+        }
+
         const readline = require('readline');
         const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout
         });
-        
+
         return new Promise((resolve, reject) => {
+            // Set timeout for user input (30 seconds)
+            const timeout = setTimeout(() => {
+                console.log(yellow('\n⏰ Timeout reached - no response received.'));
+                console.log(gray('Setup cancelled. Run "npm run i18ntk-setup" when you\'re ready.'));
+                rl.close();
+                process.exit(1);
+            }, 30000); // 30 second timeout
+
             rl.question(cyan('Would you like to re-run setup to fix this? (Y/n): '), async (answer) => {
+                clearTimeout(timeout);
                 rl.close();
-                
+
                 if (answer.toLowerCase() === 'n' || answer.toLowerCase() === 'no') {
                     console.log(gray('Operation cancelled.'));
                     process.exit(0);
                 }
-                
+
                 console.log(green(`${getIcon('rocket')} Running setup...`));
-                
+
                 try {
                     const setupPath = path.join(__dirname, '..', 'main', 'i18ntk-setup.js');
-                    if (fs.existsSync(setupPath)) {
+                    if (SecurityUtils.safeExistsSync(setupPath)) {
                         try {
                             const setup = require(setupPath);
                             // Use the run function which properly instantiates the class
@@ -223,6 +298,7 @@ static async handleInvalidConfig() {
 
     static checkSetupCompleteAsync() {
         // Return existing promise if already in progress
+        // Add debugging for setup check
         if (SetupEnforcer._setupCheckInProgress && SetupEnforcer._setupCheckPromise) {
             return SetupEnforcer._setupCheckPromise;
         }
@@ -230,22 +306,30 @@ static async handleInvalidConfig() {
         // Create new promise and store it
         SetupEnforcer._setupCheckInProgress = true;
         SetupEnforcer._setupCheckPromise = new Promise(async (resolve, reject) => {
-            try {
-                const configPath = path.join(process.cwd(), 'settings', 'i18ntk-config.json');
-                
-                if (!fs.existsSync(configPath)) {
-                    await SetupEnforcer.handleMissingSetup();
-                    // After setup is done, re-check the config
-                    if (fs.existsSync(configPath)) {
-                        resolve(true);
-                    } else {
+             try {
+                 // Avoid circular dependency - use direct path resolution
+                 const path = require('path');
+                 const configPath = path.join(process.cwd(), '.i18ntk-config');
+                const exists = SecurityUtils.safeExistsSync(configPath);
+                if (!exists) {
+                    await SetupEnforcer.handleMissingSetup();
+                    // After setup is done, re-check the config
+                    const existsAfter = SecurityUtils.safeExistsSync(configPath);
+                    if (existsAfter) {
+                        resolve(true);
+                    } else {
                         process.exit(0);
                     }
                     return;
                 }
 
                 try {
-                    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+                    const configRaw = SecurityUtils.safeReadFileSync(configPath, path.dirname(configPath), 'utf8');
+                    const config = SecurityUtils.safeParseJSON(configRaw);
+                    if (!config || typeof config !== 'object') {
+                        await SetupEnforcer.handleInvalidConfig();
+                        process.exit(0);
+                    }
                     
                     // Check if setup has been explicitly marked as completed
                     if (config.setup && config.setup.completed === true) {
@@ -254,13 +338,17 @@ static async handleInvalidConfig() {
                     }
                     
                     // Fallback: check if config has required fields (for backward compatibility)
-                    if (!config.version || !config.sourceDir || !config.detectedFramework) {
+                    if (!config.version || !config.sourceDir || (!config.detectedFramework && !(config.framework && config.framework.detected !== false))) {
                         await SetupEnforcer.handleIncompleteSetup();
                         // After setup is done, re-check the config
-                        const newConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+                        const newConfigRaw = SecurityUtils.safeReadFileSync(configPath, path.dirname(configPath), 'utf8');
+                        const newConfig = SecurityUtils.safeParseJSON(newConfigRaw);
+                        if (!newConfig || typeof newConfig !== 'object') {
+                            process.exit(0);
+                        }
                         if (newConfig.setup && newConfig.setup.completed === true) {
                             resolve(true);
-                        } else if (newConfig.version && newConfig.sourceDir && newConfig.detectedFramework) {
+                        } else if (newConfig.version && newConfig.sourceDir && (newConfig.detectedFramework || (newConfig.framework && newConfig.framework.detected !== false))) {
                             resolve(true);
                         } else {
                             process.exit(0);
@@ -273,10 +361,14 @@ static async handleInvalidConfig() {
                     await SetupEnforcer.handleInvalidConfig();
                     // After setup is done, re-check the config
                     try {
-                        const newConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+                        const newConfigRaw = SecurityUtils.safeReadFileSync(configPath, path.dirname(configPath), 'utf8');
+                        const newConfig = SecurityUtils.safeParseJSON(newConfigRaw);
+                        if (!newConfig || typeof newConfig !== 'object') {
+                            process.exit(0);
+                        }
                         if (newConfig.setup && newConfig.setup.completed === true) {
                             resolve(true);
-                        } else if (newConfig.version && newConfig.sourceDir && newConfig.detectedFramework) {
+                        } else if (newConfig.version && newConfig.sourceDir && (newConfig.detectedFramework || (newConfig.framework && newConfig.framework.detected !== false))) {
                             resolve(true);
                         } else {
                             process.exit(0);
@@ -296,4 +388,4 @@ static async handleInvalidConfig() {
     }
 }
 
-module.exports = SetupEnforcer;
+module.exports = SetupEnforcer;

package/utils/setup-validator.js

@@ -9,6 +9,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const SecurityUtils = require('./security');
 
 
 class SetupValidator {
@@ -63,9 +64,9 @@ class SetupValidator {
     async loadConfiguration() {
         const configPath = path.join(process.cwd(), 'i18ntk-config.json');
         
-        if (fs.existsSync(configPath)) {
+        if (SecurityUtils.safeExistsSync(configPath)) {
             try {
-                this.config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+                this.config = JSON.parse(SecurityUtils.safeReadFileSync(configPath, path.dirname(configPath), 'utf8'));
                 this.results.checks.push({
                     category: 'configuration',
                     message: 'Configuration file found and valid',
@@ -151,7 +152,7 @@ class SetupValidator {
         const outputDir = this.config.outputDir;
 
         // Check source directory
-        if (fs.existsSync(sourceDir)) {
+        if (SecurityUtils.safeExistsSync(sourceDir)) {
             const stats = fs.statSync(sourceDir);
             if (stats.isDirectory()) {
                 const files = fs.readdirSync(sourceDir);
@@ -193,7 +194,7 @@ class SetupValidator {
         }
 
         // Check output directory
-        if (!fs.existsSync(outputDir)) {
+        if (!SecurityUtils.safeExistsSync(outputDir)) {
             fs.mkdirSync(outputDir, { recursive: true });
             this.results.checks.push({
                 category: 'directories',
@@ -229,11 +230,11 @@ class SetupValidator {
                 recommended: ['django', 'flask-babel', 'babel'],
                 dev: ['pytest']
             },
-            go: {
-                required: [],
-                recommended: ['github.com/nicksnyder/go-i18n/v2/i18n'],
-                dev: []
-            },
+            go: {
+                required: [],
+                recommended: ['go-i18n'],
+                dev: []
+            },
             java: {
                 required: [],
                 recommended: ['spring-boot-starter-web', 'spring-context'],
@@ -258,9 +259,9 @@ class SetupValidator {
         switch (language) {
             case 'javascript':
             case 'typescript':
-                if (fs.existsSync(packageJsonPath)) {
+                if (SecurityUtils.safeExistsSync(packageJsonPath)) {
                     try {
-                        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                        const packageJson = JSON.parse(SecurityUtils.safeReadFileSync(packageJsonPath, path.dirname(packageJsonPath), 'utf8'));
                         const allDeps = { ...packageJson.dependencies, ...packageJson.devDependencies };
                         
                         const recommended = dependencies[language].recommended;
@@ -297,8 +298,8 @@ class SetupValidator {
                 break;
 
             case 'python':
-                if (fs.existsSync(requirementsPath)) {
-                    const requirements = fs.readFileSync(requirementsPath, 'utf8');
+                if (SecurityUtils.safeExistsSync(requirementsPath)) {
+                    const requirements = SecurityUtils.safeReadFileSync(requirementsPath, path.dirname(requirementsPath), 'utf8');
                     const recommended = dependencies[language].recommended;
                     const found = recommended.filter(dep => requirements.includes(dep));
                     
@@ -324,8 +325,8 @@ class SetupValidator {
                 break;
 
             case 'go':
-                if (fs.existsSync(goModPath)) {
-                    const goMod = fs.readFileSync(goModPath, 'utf8');
+                if (SecurityUtils.safeExistsSync(goModPath)) {
+                    const goMod = SecurityUtils.safeReadFileSync(goModPath, path.dirname(goModPath), 'utf8');
                     const recommended = dependencies[language].recommended;
                     const found = recommended.filter(dep => goMod.includes(dep));
                     
@@ -351,8 +352,8 @@ class SetupValidator {
                 break;
 
             case 'java':
-                if (fs.existsSync(pomPath)) {
-                    const pom = fs.readFileSync(pomPath, 'utf8');
+                if (SecurityUtils.safeExistsSync(pomPath)) {
+                    const pom = SecurityUtils.safeReadFileSync(pomPath, path.dirname(pomPath), 'utf8');
                     const recommended = dependencies[language].recommended;
                     const found = recommended.filter(dep => pom.includes(dep));
                     
@@ -377,9 +378,9 @@ class SetupValidator {
                 break;
 
             case 'php':
-                if (fs.existsSync(composerPath)) {
+                if (SecurityUtils.safeExistsSync(composerPath)) {
                     try {
-                        const composer = JSON.parse(fs.readFileSync(composerPath, 'utf8'));
+                        const composer = JSON.parse(SecurityUtils.safeReadFileSync(composerPath, path.dirname(composerPath), 'utf8'));
                         const allDeps = { ...composer.require, ...composer['require-dev'] };
                         
                         const recommended = dependencies[language].recommended;
@@ -417,6 +418,15 @@ class SetupValidator {
         }
     }
 
+    estimatePerformance(mode) {
+        const performanceMap = {
+            extreme: { improvement: 87, time: '38.90ms' },
+            ultra: { improvement: 78, time: '336.8ms' },
+            optimized: { improvement: 45, time: '847.9ms' }
+        };
+        return performanceMap[mode] || { improvement: 0, time: 'unknown' };
+    }
+
     async validatePerformanceSettings() {
         if (!this.config) return;
 
@@ -486,15 +496,6 @@ class SetupValidator {
         };
     }
 
-    estimatePerformance(mode) {
-        const performanceMap = {
-            extreme: { improvement: 87, time: '38.90ms' },
-            ultra: { improvement: 78, time: '336.8ms' },
-            optimized: { improvement: 45, time: '847.9ms' }
-        };
-        return performanceMap[mode] || { improvement: 0, time: 'unknown' };
-    }
-
     async validateSecuritySettings() {
         const security = this.config?.security || {};
         
@@ -537,7 +538,7 @@ class SetupValidator {
 
         // Check for sensitive data in locale files
         const sourceDir = this.config?.sourceDir;
-        if (sourceDir && fs.existsSync(sourceDir)) {
+        if (sourceDir && SecurityUtils.safeExistsSync(sourceDir)) {
             const sensitivePatterns = [
                 /password/i,
                 /secret/i,
@@ -552,7 +553,7 @@ class SetupValidator {
             for (const file of files) {
                 const filePath = path.join(sourceDir, file);
                 if (fs.statSync(filePath).isFile()) {
-                    const content = fs.readFileSync(filePath, 'utf8');
+                    const content = SecurityUtils.safeReadFileSync(filePath, path.dirname(filePath), 'utf8');
                     
                     for (const pattern of sensitivePatterns) {
                         if (pattern.test(content)) {
@@ -652,7 +653,7 @@ class SetupValidator {
             }
         };
 
-        fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+        SecurityUtils.safeWriteFileSync(reportPath, JSON.stringify(report, null, 2));
         console.log(`\n📋 Validation report saved: ${reportPath}`);
 
         // Print summary
@@ -713,4 +714,4 @@ if (require.main === module) {
     validator.validate().catch(console.error);
 }
 
-module.exports = SetupValidator;
+module.exports = SetupValidator;

package/utils/ultra-performance-optimizer.js

@@ -4,9 +4,11 @@
  * Targets: 35ms processing for 200k keys with <10MB memory
  */
 
-const fs = require('fs').promises;
-const path = require('path');
-const { performance } = require('perf_hooks');
+const fs = require('fs').promises;
+const path = require('path');
+const perf = (globalThis.performance && typeof globalThis.performance.now === 'function')
+  ? globalThis.performance
+  : { now: () => Date.now() };
 
 class UltraPerformanceOptimizer {
   constructor(options = {}) {
@@ -42,7 +44,7 @@ class UltraPerformanceOptimizer {
    * Initialize ultra-optimization
    */
   async initialize() {
-    this.stats.startTime = performance.now();
+    this.stats.startTime = perf.now();
     this.stats.memoryStart = process.memoryUsage();
     
     // Force garbage collection if available
@@ -265,7 +267,7 @@ class UltraPerformanceOptimizer {
    * Get performance statistics
    */
   getStats() {
-    this.stats.endTime = performance.now();
+    this.stats.endTime = perf.now();
     this.stats.memoryEnd = process.memoryUsage();
     
     const processingTime = this.stats.endTime - this.stats.startTime;
@@ -289,9 +291,9 @@ class UltraPerformanceOptimizer {
   async runUltraBenchmark(filePaths) {
     console.log('🚀 Starting Ultra-Extreme Performance Benchmark...');
     
-    const start = performance.now();
-    const results = await this.processFiles(filePaths);
-    const end = performance.now();
+    const start = perf.now();
+    const results = await this.processFiles(filePaths);
+    const end = perf.now();
     
     const stats = this.getStats();
     
@@ -347,4 +349,4 @@ if (require.main === module) {
     console.error('❌ Benchmark failed:', error);
     process.exit(1);
   });
-}
+}

package/utils/watch-locales.js

@@ -1,8 +1,9 @@
 const fs = require('fs');
 const path = require('path');
+const SecurityUtils = require('./security');
 
 function watchDirectory(dir, callback, watchers) {
-  if (!fs.existsSync(dir)) return;
+  if (!SecurityUtils.safeExistsSync(dir)) return;
   const watcher = fs.watch(dir, (event, filename) => {
     if (filename && filename.endsWith('.json')) {
       callback(path.join(dir, filename));

package/utils/prompt-fixed.js

@@ -1,55 +0,0 @@
-const readline = require('readline');
-const { logger } = require('./logger');
-
-class Prompt {
-  constructor() {
-    this.rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-  }
-
-  close() {
-    this.rl.close();
-  }
-
-  async question(questionText) {
-    return new Promise((resolve) => {
-      this.rl.question(questionText, (answer) => {
-        resolve(answer.trim());
-      });
-    });
-  }
-
-  async confirm(questionText, defaultValue = false) {
-    const answer = await this.question(`${questionText} (${defaultValue ? 'Y/n' : 'y/N'}) `);
-    if (answer === '') return defaultValue;
-    return /^y|yes$/i.test(answer);
-  }
-
-  async select(questionText, choices, defaultIndex = 0) {
-    logger.log(`\n${questionText}:`);
-    choices.forEach((choice, index) => {
-      logger.log(`  ${index + 1}. ${choice}`);
-    });
-
-    while (true) {
-      const answer = await this.question(`\nSelect an option (1-${choices.length}): `);
-      const selected = parseInt(answer, 10) - 1;
-      if (!isNaN(selected) && selected >= 0 && selected < choices.length) {
-        return selected;
-      }
-      logger.log('Invalid selection. Please try again.');
-    }
-  }
-
-  async input(questionText, defaultValue = '') {
-    const answer = await this.question(`${questionText}${defaultValue ? ` [${defaultValue}]` : ''}: `);
-    return answer || defaultValue;
-  }
-}
-
-const prompt = new Prompt();
-process.on('exit', () => prompt.close());
-
-module.exports = prompt;