i18ntk 2.5.1 → 3.0.0

package/main/manage/commands/ScannerCommand.js

@@ -175,9 +175,9 @@ class ScannerCommand {
                 if (pyproject.includes('Flask')) return 'flask';
             }
 
-            // Check for Python files
-            const hasPythonFiles = fs.readdirSync(projectRoot, { recursive: true })
-                .some(file => file.endsWith && file.endsWith('.py'));
+            // Check for Python files using safeReaddirSync
+            const pythonItems = SecurityUtils.safeReaddirSync(projectRoot, projectRoot, { withFileTypes: true }) || [];
+            const hasPythonFiles = pythonItems.some(item => item.isFile && item.name && item.name.endsWith('.py'));
             if (hasPythonFiles) return 'python';
         } catch (error) {
             // Continue to JS frameworks
@@ -414,20 +414,22 @@ class ScannerCommand {
         const extensions = ['.js', '.jsx', '.ts', '.tsx', '.vue', '.html', '.svelte', '.py', '.pyx', '.pyi'];
 
         const scanRecursive = (currentDir) => {
-            const items = fs.readdirSync(currentDir);
+            const items = SecurityUtils.safeReaddirSync(currentDir, path.dirname(currentDir), { withFileTypes: true });
+            if (!items) return;
 
             for (const item of items) {
-                const fullPath = path.join(currentDir, item);
-                const stat = fs.statSync(fullPath);
+                const fullPath = path.join(currentDir, item.name);
+                const stat = SecurityUtils.safeStatSync(fullPath, currentDir);
+                if (!stat) continue;
 
                 if (stat.isDirectory()) {
-                    if (!item.startsWith('.') && !this.shouldExcludeFile(fullPath, exclusions)) {
+                    if (!item.name.startsWith('.') && !this.shouldExcludeFile(fullPath, exclusions)) {
                         scanRecursive(fullPath);
                     }
                 } else if (stat.isFile()) {
-                    const ext = path.extname(item);
+                    const ext = path.extname(item.name);
                     if (extensions.includes(ext) && !this.shouldExcludeFile(fullPath, exclusions)) {
-                        if (!includeTests && (item.includes('.test.') || item.includes('.spec.'))) {
+                        if (!includeTests && (item.name.includes('.test.') || item.name.includes('.spec.'))) {
                             continue;
                         }
 
@@ -449,7 +451,7 @@ class ScannerCommand {
 
     async generateReport(results, outputDir) {
         if (!SecurityUtils.safeExistsSync(outputDir, path.dirname(outputDir))) {
-            fs.mkdirSync(outputDir, { recursive: true });
+            SecurityUtils.safeMkdirSync(outputDir, process.cwd(), { recursive: true });
         }
 
         const timestamp = new Date().toISOString().replace(/[:.]/g, '-');

package/main/manage/commands/TranslateCommand.js

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+
+/**
+ * I18NTK TRANSLATE COMMAND
+ *
+ * Interactive menu-driven auto-translation using Google Translate.
+ * Wraps i18ntk-translate.js behind a user-friendly menu flow.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getUnifiedConfig } = require('../../../utils/config-helper');
+const { loadTranslations } = require('../../../utils/i18n-helper');
+const SetupEnforcer = require('../../../utils/setup-enforcer');
+
+class TranslateCommand {
+    constructor(config = {}, ui = null) {
+        this.config = config;
+        this.ui = ui;
+        this.prompt = null;
+        this.isNonInteractiveMode = false;
+        this.safeClose = null;
+        this.sourceDir = null;
+        this.sourceLang = null;
+        this.targetLang = null;
+    }
+
+    setRuntimeDependencies(prompt, isNonInteractiveMode, safeClose) {
+        this.prompt = prompt;
+        this.isNonInteractiveMode = isNonInteractiveMode;
+        this.safeClose = safeClose;
+    }
+
+    async execute(options = {}) {
+        try {
+            await SetupEnforcer.checkSetupCompleteAsync();
+        } catch (error) {
+            console.error('Setup check failed:', error.message);
+            return { success: false, error: 'Setup required' };
+        }
+
+        loadTranslations('en', path.resolve(__dirname, '..', '..', '..', 'ui-locales'));
+
+        const config = this.config || {};
+        const unified = getUnifiedConfig(config);
+
+        const defaultSourceDir = unified.sourceDir || unified.i18nDir || path.resolve(process.cwd(), 'locales', 'en');
+        this.sourceLang = unified.sourceLanguage || 'en';
+
+        console.log('\n============================================================');
+        console.log('  \u{1F310} AUTO TRANSLATE (BETA)');
+        console.log('============================================================');
+
+        if (this.isNonInteractiveMode) {
+            this.sourceDir = defaultSourceDir;
+            if (!fs.existsSync(this.sourceDir)) {
+                console.error(`Source locale directory not found: ${this.sourceDir}`);
+                return { success: false, error: 'Source directory not found' };
+            }
+            const jsonFiles = fs.readdirSync(this.sourceDir).filter(f => f.endsWith('.json')).sort();
+            return await this.nonInteractiveFlow(jsonFiles);
+        }
+
+        const { ask } = require('../../../utils/cli');
+
+        // Step 1: Choose source directory
+        this.sourceDir = await this.promptSourceDir(ask, defaultSourceDir);
+        if (!this.sourceDir) return { success: false, error: 'No source directory selected' };
+
+        // Step 2: Choose source language
+        this.sourceLang = await this.promptSourceLang(ask);
+        if (!this.sourceLang) return { success: false, error: 'No source language selected' };
+
+        const jsonFiles = fs.readdirSync(this.sourceDir)
+            .filter(f => f.endsWith('.json'))
+            .sort();
+
+        if (jsonFiles.length === 0) {
+            console.error(`No JSON files found in: ${this.sourceDir}`);
+            return { success: false, error: 'No source files found' };
+        }
+
+        return await this.interactiveFlow(jsonFiles, ask);
+    }
+
+    async promptSourceDir(ask, defaultDir) {
+        while (true) {
+            console.log(`\n  Source directory [default: ${defaultDir}]`);
+            console.log('  Press Enter for default, or type a custom path.');
+            const input = await ask('  > ');
+
+            if (!input.trim()) {
+                if (!fs.existsSync(defaultDir)) {
+                    console.log(`  Default directory not found: ${defaultDir}`);
+                    console.log('  Please enter an existing directory with JSON locale files.');
+                    continue;
+                }
+                console.log(`  Using default: ${defaultDir}`);
+                return defaultDir;
+            }
+
+            const resolved = path.resolve(process.cwd(), input.trim());
+            if (!fs.existsSync(resolved)) {
+                console.log(`  Directory not found: ${resolved}`);
+                continue;
+            }
+            if (!fs.statSync(resolved).isDirectory()) {
+                console.log(`  Not a directory: ${resolved}`);
+                continue;
+            }
+            return resolved;
+        }
+    }
+
+    async promptSourceLang(ask) {
+        while (true) {
+            console.log(`\n  Source language code [default: ${this.sourceLang}]`);
+            const input = await ask('  > ');
+
+            if (!input.trim()) {
+                return this.sourceLang;
+            }
+
+            const lang = input.trim().toLowerCase();
+            if (lang.length >= 2) {
+                return lang;
+            }
+            console.log('  Invalid language code. Use 2+ characters (e.g. en, de, fr).');
+        }
+    }
+
+    async interactiveFlow(jsonFiles, ask) {
+
+        console.log('\n  Target language code(s)');
+        console.log('  Enter one or more comma/space-separated codes');
+        console.log('  (e.g. de, es, fr  or  de es fr  or  de):');
+        const langInput = await ask('  > ');
+
+        const targetLangs = langInput
+            .trim()
+            .split(/[,;\s]+/)
+            .map(s => s.toLowerCase().trim())
+            .filter(s => s.length >= 2);
+
+        if (targetLangs.length === 0) {
+            console.log('  No valid language codes entered. Aborting.');
+            return { success: false, error: 'Invalid language code' };
+        }
+
+        console.log(`\n  Target languages: ${targetLangs.join(', ')}`);
+
+        console.log(`\n  Which file(s) to translate?`);
+        console.log(`    a) All files (${jsonFiles.join(', ')})`);
+        jsonFiles.forEach((f, i) => {
+            console.log(`    ${i + 1}) ${f}`);
+        });
+
+        const fileChoice = await ask('\n  Choice [a/1-9]: ');
+        let sourceFiles;
+
+        if (fileChoice.toLowerCase() === 'a') {
+            sourceFiles = jsonFiles.map(f => path.join(this.sourceDir, f));
+        } else {
+            const idx = parseInt(fileChoice, 10) - 1;
+            if (isNaN(idx) || idx < 0 || idx >= jsonFiles.length) {
+                console.log('  Invalid choice. Aborting.');
+                return { success: false, error: 'Invalid file choice' };
+            }
+            sourceFiles = [path.join(this.sourceDir, jsonFiles[idx])];
+        }
+
+        // Dry-run for first language only (all languages use same source so same keys)
+        const firstLang = targetLangs[0];
+        console.log(`\n  Dry-run preview for "${firstLang}"...\n`);
+        await this.runTranslate(sourceFiles, firstLang, { dryRun: true });
+
+        console.log('\n  Proceed with actual translation?');
+        const answer = await ask('  [y]es / [n]o: ');
+        if (!/^y|yes$/i.test(answer.trim())) {
+            console.log('  Translation cancelled.');
+            return { success: true, cancelled: true };
+        }
+
+        let results = [];
+        for (const lang of targetLangs) {
+            console.log(`\n  Translating to "${lang}"...\n`);
+            try {
+                await this.runTranslate(sourceFiles, lang, { dryRun: false });
+                results.push({ lang, ok: true });
+            } catch (e) {
+                console.error(`  Failed for "${lang}": ${e.message}`);
+                results.push({ lang, ok: false, error: e.message });
+            }
+        }
+
+        console.log('\n  Summary:');
+        for (const r of results) {
+            console.log(`    ${r.ok ? '\u{2705}' : '\u{274C}'} ${r.lang}${r.error ? ' (' + r.error + ')' : ''}`);
+        }
+        console.log('\n  Translation complete!');
+        return { success: true, results };
+    }
+
+    async nonInteractiveFlow(jsonFiles) {
+        console.log('\n  Non-interactive mode. Use direct CLI instead:');
+        console.log('    i18ntk-translate <source> <lang> [options]');
+        return { success: false, error: 'Non-interactive mode not supported from menu' };
+    }
+
+    async runTranslate(sourceFiles, targetLang, opts = {}) {
+        const { spawn } = require('child_process');
+
+        for (const src of sourceFiles) {
+            const args = [
+                path.resolve(__dirname, '..', '..', 'i18ntk-translate.js'),
+                src,
+                targetLang,
+                '--no-confirm',
+                '--skip-placeholders',
+                '--report-stdout'
+            ];
+
+            if (opts.dryRun) {
+                args.push('--dry-run');
+            }
+
+            await new Promise((resolve, reject) => {
+                const proc = spawn('node', args, {
+                    stdio: 'inherit',
+                    cwd: process.cwd()
+                });
+                proc.on('close', (code) => {
+                    if (code === 0) resolve();
+                    else reject(new Error(`Exit code ${code}`));
+                });
+                proc.on('error', reject);
+            });
+        }
+    }
+}
+
+module.exports = TranslateCommand;

package/main/manage/commands/ValidateCommand.js

@@ -94,8 +94,8 @@ class ValidateCommand {
                 } else {
                     console.warn(t('config.dirFallbackWarning', { dir: this.sourceDir, fallback: this.sourceLanguageDir }) ||
                         `Warning: Directory ${this.sourceDir} not found. Using ${this.sourceLanguageDir}.`);
-                    if (!SecurityUtils.safeExistsSync(this.sourceLanguageDir)) {
-                        fs.mkdirSync(this.sourceLanguageDir, { recursive: true });
+                    if (!SecurityUtils.safeExistsSync(this.sourceLanguageDir, process.cwd())) {
+                        SecurityUtils.safeMkdirSync(this.sourceLanguageDir, process.cwd(), { recursive: true });
                     }
                 }
             }
@@ -185,13 +185,15 @@ class ValidateCommand {
                 throw new Error(`Source directory not found: ${this.sourceDir}`);
             }
 
-            const languages = fs.readdirSync(this.sourceDir)
-                .filter(item => {
-                    const itemPath = path.join(this.sourceDir, item);
-                    return fs.statSync(itemPath).isDirectory() &&
-                           item !== this.config.sourceLanguage &&
-                           !this.isExcludedLanguageDirectory(item);
-                });
+            const items = SecurityUtils.safeReaddirSync(this.sourceDir, process.cwd(), { withFileTypes: true });
+            if (!items) {
+                throw new Error(`Source directory not found: ${this.sourceDir}`);
+            }
+
+            const languages = items
+                .filter(item => item.isDirectory())
+                .filter(item => item.name !== this.config.sourceLanguage && !this.isExcludedLanguageDirectory(item.name))
+                .map(item => item.name);
 
             return languages;
         } catch (error) {
@@ -209,11 +211,13 @@ class ValidateCommand {
                 return [];
             }
 
-            const files = fs.readdirSync(languageDir)
-                .filter(file => {
-                    return file.endsWith('.json') &&
-                          !this.config.excludeFiles.includes(file);
-                });
+            const items = SecurityUtils.safeReaddirSync(languageDir, process.cwd(), { withFileTypes: true });
+            if (!items) return [];
+
+            const files = items
+                .filter(item => item.isFile() && item.name.endsWith('.json') &&
+                    !this.config.excludeFiles.includes(item.name))
+                .map(item => item.name);
 
             return files;
         } catch (error) {
@@ -663,10 +667,10 @@ class ValidateCommand {
 
                 // Delete old validation report if it exists
                 const reportPath = path.join(process.cwd(), 'validation-report.txt');
-                SecurityUtils.validatePath(reportPath);
+                const validatedPath = SecurityUtils.validatePath(reportPath, process.cwd());
 
-                if (SecurityUtils.safeExistsSync(reportPath)) {
-                    fs.unlinkSync(reportPath);
+                if (validatedPath && SecurityUtils.safeExistsSync(validatedPath, process.cwd())) {
+                    SecurityUtils.safeUnlinkSync(validatedPath, process.cwd());
                     console.log(t('validate.deletedOldReport'));
 
                     SecurityUtils.logSecurityEvent(t('validate.fileDeleted'), 'info', {

package/main/manage/index.js

@@ -765,10 +765,11 @@ class I18nManager {
 
         function findFiles(dir, results = []) {
             try {
-                const items = fs.readdirSync(dir);
+                const items = SecurityUtils.safeReaddirSync(dir, cwd, { withFileTypes: true });
+                if (!items) return results;
 
                 for (const item of items) {
-                    const fullPath = path.join(dir, item);
+                    const fullPath = path.join(dir, item.name);
                     const relativePath = path.relative(cwd, fullPath);
 
                     if (shouldIgnore(relativePath)) {
@@ -776,14 +777,12 @@ class I18nManager {
                     }
 
                     try {
-                        const stat = fs.statSync(fullPath);
-
-                        if (stat.isDirectory()) {
+                        if (item.isDirectory()) {
                             findFiles(fullPath, results);
-                        } else if (stat.isFile()) {
+                        } else if (item.isFile()) {
                             // Check if file matches any of our patterns
                             for (const pattern of patterns) {
-                                if (matchesPattern(item, pattern)) {
+                                if (matchesPattern(item.name, pattern)) {
                                     results.push(relativePath);
                                     break;
                                 }
@@ -879,6 +878,7 @@ class I18nManager {
             console.log(`11. ${t('menu.options.help')}`);
             console.log(`12. ${t('menu.options.language')}`);
             console.log(`13. ${t('menu.options.scanner')}`);
+            console.log(`14. ${t('menu.options.translate')}`);
             console.log(`0. ${t('menu.options.exit')}`);
 
             console.log('\n' + t('menu.nonInteractiveModeWarning'));
@@ -904,6 +904,7 @@ class I18nManager {
         console.log(`11. ${t('menu.options.help')}`);
         console.log(`12. ${t('menu.options.language')}`);
         console.log(`13. ${t('menu.options.scanner')}`);
+        console.log(`14. ${t('menu.options.translate')}`);
         console.log(`0. ${t('menu.options.exit')}`);
 
         const choice = await this.prompt('\n' + t('menu.selectOptionPrompt'));
@@ -1008,11 +1009,15 @@ class I18nManager {
             case '12':
                 await this.showLanguageMenu();
                 break;
-            case '13':
-                await this.executeCommand('scanner', {fromMenu: true});
-                await this.showInteractiveMenu();
-                return;
-            case '0':
+            case '13':
+                await this.executeCommand('scanner', {fromMenu: true});
+                await this.showInteractiveMenu();
+                return;
+            case '14':
+                await this.executeCommand('translate', {fromMenu: true});
+                await this.showInteractiveMenu();
+                return;
+            case '0':
                 console.log(t('menu.goodbye'));
                 this.safeClose();
                 process.exit(0);

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "i18ntk",
-  "version": "2.5.1",
-  "description": "Zero-dependency internationalization toolkit for setup, scanning, analysis, validation, usage tracking, fixing, reporting, and runtime translation loading.",
+  "version": "3.0.0",
+  "description": "Zero-dependency internationalization toolkit for setup, scanning, analysis, validation, auto translation, fixing, reporting, and runtime translation loading.",
   "keywords": [
     "i18n",
     "internationalization",
     "localization",
     "translation",
+    "auto-translation",
+    "google-translate",
     "l10n",
     "multilingual",
     "i18next",
@@ -76,12 +78,14 @@
     "i18ntk-doctor": "main/i18ntk-doctor.js",
     "i18ntk-fixer": "main/i18ntk-fixer.js",
     "i18ntk-scanner": "main/i18ntk-scanner.js",
-    "i18ntk-backup": "main/i18ntk-backup.js"
+    "i18ntk-backup": "main/i18ntk-backup.js",
+    "i18ntk-translate": "main/i18ntk-translate.js"
   },
   "files": [
     "main/i18ntk-analyze.js",
     "main/i18ntk-backup-class.js",
     "main/i18ntk-backup.js",
+    "main/i18ntk-translate.js",
     "main/i18ntk-complete.js",
     "main/i18ntk-doctor.js",
     "main/i18ntk-fixer.js",
@@ -114,6 +118,11 @@
     "utils/extractors/regex.js",
     "utils/format-manager.js",
     "utils/formats/json.js",
+    "utils/translate/placeholder.js",
+    "utils/translate/api.js",
+    "utils/translate/traverse.js",
+    "utils/translate/report.js",
+    "utils/translate/cli.js",
     "utils/framework-detector.js",
     "utils/i18n-helper.js",
     "utils/init-helper.js",
@@ -132,6 +141,7 @@
     "utils/watch-locales.js",
     "LICENSE",
     "README.md",
+    "CHANGELOG.md",
     "CODE_OF_CONDUCT.md",
     "CONTRIBUTING.md",
     "FUNDING.md",

package/runtime/enhanced.js

@@ -24,6 +24,33 @@ const IV_LENGTH = 16;
 const AUTH_TAG_LENGTH = 16;
 const SALT_LENGTH = 32;
 
+// Track active instances to ensure cleanup is registered only once
+let activeInstances = new Set();
+let processHandlersRegistered = false;
+
+function registerProcessHandlers() {
+  if (processHandlersRegistered) return;
+  processHandlersRegistered = true;
+
+  process.on('exit', () => {
+    for (const instance of activeInstances) {
+      try { instance.cleanup(); } catch (_) { /* best-effort */ }
+    }
+  });
+  process.on('SIGINT', () => {
+    for (const instance of activeInstances) {
+      try { instance.cleanup(); } catch (_) { /* best-effort */ }
+    }
+    process.exit(0);
+  });
+  process.on('uncaughtException', () => {
+    for (const instance of activeInstances) {
+      try { instance.cleanup(); } catch (_) { /* best-effort */ }
+    }
+    process.exit(1);
+  });
+}
+
 class I18nEnhancedRuntime extends EventEmitter {
   constructor() {
     super();
@@ -84,14 +111,14 @@ class I18nEnhancedRuntime extends EventEmitter {
       () => this.checkMemoryUsage(), 
       30000 // Check every 30 seconds
     );
-    
-    // Ensure cleanup on process exit
-    if (process && process.on) {
-      process.on('exit', () => this.cleanup());
-      process.on('SIGINT', () => this.cleanup());
-      process.on('uncaughtException', () => this.cleanup());
+    if (typeof this.memoryCheckInterval.unref === 'function') {
+      this.memoryCheckInterval.unref();
     }
     
+    // Register this instance for process-wide cleanup
+    activeInstances.add(this);
+    registerProcessHandlers();
+    
     // Add default translations namespace
     this.addNamespace('default', {
       en: {
@@ -178,12 +205,32 @@ class I18nEnhancedRuntime extends EventEmitter {
   }
 
   async decryptData(encryptedData, key = this.encryptionKey) {
-    if (!key) throw new Error('Encryption key not set');
+    if (!key) {
+      throw new EncryptionError('Encryption key not set', {
+        operation: 'decrypt',
+        keyType: typeof key
+      });
+    }
     
     try {
-      const data = JSON.parse(encryptedData);
-      const decipher = crypto.createDecipheriv(ALGORITHM, Buffer.from(key, 'hex'), Buffer.from(data.iv, 'hex'));
+      let data;
+      try {
+        data = JSON.parse(encryptedData);
+      } catch (parseError) {
+        throw new EncryptionError('Failed to parse encrypted data', {
+          operation: 'decrypt',
+          error: parseError.message
+        });
+      }
+      
+      if (!data || !data.iv || !data.authTag || !data.encrypted) {
+        throw new EncryptionError('Invalid encrypted data format', {
+          operation: 'decrypt',
+          missingFields: ['iv', 'authTag', 'encrypted'].filter(f => !(f in (data || {})))
+        });
+      }
       
+      const decipher = crypto.createDecipheriv(ALGORITHM, Buffer.from(key, 'hex'), Buffer.from(data.iv, 'hex'));
       decipher.setAuthTag(Buffer.from(data.authTag, 'hex'));
       
       let decrypted = decipher.update(data.encrypted, 'hex', 'utf8');
@@ -191,7 +238,12 @@ class I18nEnhancedRuntime extends EventEmitter {
       
       return decrypted;
     } catch (error) {
-      throw new Error(`Decryption failed: ${error.message}`);
+      if (error instanceof SecureError) throw error;
+      
+      throw new EncryptionError('Decryption failed', {
+        operation: 'decrypt',
+        errorId: crypto.randomBytes(4).toString('hex')
+      });
     }
   }
 
@@ -619,6 +671,8 @@ class I18nEnhancedRuntime extends EventEmitter {
     if (this.config.encryption) {
       this.config.encryption.salt = null;
     }
+    
+    activeInstances.delete(this);
   }
   
   // Add or update a cache entry

package/runtime/i18ntk.d.ts

@@ -447,12 +447,12 @@ export interface I18nRuntime {
  */
 export interface BasicI18nRuntime {
   /**
-   * Translate a key with parameters
+   * Translate a key with parameters (synchronous)
    */
   translate(key: string, params?: TranslationParams): string;
   
   /**
-   * Alias for translate function
+   * Alias for translate function (synchronous)
    */
   t(key: string, params?: TranslationParams): string;
   
@@ -467,7 +467,7 @@ export interface BasicI18nRuntime {
   getLanguage(): string;
   
   /**
-   * Get available languages
+   * Get available languages (synchronous)
    */
   getAvailableLanguages(): string[];
   
@@ -478,16 +478,20 @@ export interface BasicI18nRuntime {
 }
 
 /**
- * Main initialization function
+ * Initialize the enhanced i18ntk runtime (async, returns full I18nRuntime)
  */
 export declare function initI18nRuntime(config: I18nConfig): Promise<I18nRuntime>;
 
 /**
- * Basic initialization function (backward compatibility)
+ * Initialize the basic lightweight runtime (synchronous)
+ * This is the default export from 'i18ntk/runtime'
  */
-export declare function initRuntime(config: {
+export declare function initRuntime(options: {
   baseDir: string;
   language?: string;
+  fallbackLanguage?: string;
+  keySeparator?: string;
+  preload?: boolean;
 }): BasicI18nRuntime;
 
 /**