i18ntk 1.10.1 → 2.0.2

package/main/i18ntk-js.js

@@ -3,7 +3,7 @@
 /**
  * i18ntk JavaScript/TypeScript Command
  * Specialized command for JavaScript and TypeScript i18n management
- * 
+ *
  * Usage: i18ntk-js [options]
  */
 
@@ -13,7 +13,7 @@ const SecurityUtils = require(path.join(__dirname, '../utils/security.js'));
 const { getConfig, saveConfig } = require(path.join(__dirname, '../utils/config-helper.js'));
 const I18nHelper = require(path.join(__dirname, '../utils/i18n-helper.js'));
 const SetupEnforcer = require(path.join(__dirname, '../utils/setup-enforcer'));
-const { program } = require('commander');
+const { program } = require('../utils/mini-commander');
 
 (async () => {
   try {
@@ -37,29 +37,29 @@ class I18ntkJavaScriptCommand {
       /intl\.formatMessage\s*\(\s*{[^}]*id:\s*["'`]([^"'`]+)["'`]/g,
       /useTranslations?\s*\(\s*["'`]([^"'`]+)["'`]/g,
       /getTranslations?\s*\(\s*["'`]([^"'`]+)["'`]/g,
-      
+
       // React patterns
       /FormattedMessage\s+id=["'`]([^"'`]+)["'`]/g,
       /<FormattedMessage[^>]*id={["'`]([^"'`]+)["'`]}/g,
       /useTranslation\(\)\s*\.t\s*\(\s*["'`]([^"'`]+)["'`]/g,
-      
+
       // Angular patterns
       /translate\s*\|\s*translate/g,
       /\{\{\s*["'`]([^"'`]+)["'`]\s*\|\s*translate\s*}}/g,
-      
+
       // Vue patterns
       /\$t\s*\(\s*["'`]([^"'`]+)["'`]/g,
       /this\.\$t\s*\(\s*["'`]([^"'`]+)["'`]/g,
-      
+
       // Node.js patterns
       /__\s*\(\s*["'`]([^"'`]+)["'`]/g,
       /gettext\s*\(\s*["'`]([^"'`]+)["'`]/g,
-      
+
       // Template literal patterns
       /i18n\.t\s*\(\s*`([^`]+)`/g,
       /t\s*\(\s*`([^`]+)`/g
     ];
-    
+
     this.frameworks = {
       react: {
         indicators: ['package.json', 'react', 'react-dom'],
@@ -82,7 +82,7 @@ class I18ntkJavaScriptCommand {
 
   async init() {
     console.log('🔧 Initializing i18ntk JavaScript/TypeScript command...');
-    
+
     program
       .name('i18ntk-js')
       .description('i18ntk specialized for JavaScript and TypeScript applications')
@@ -104,13 +104,13 @@ class I18ntkJavaScriptCommand {
     this.options = program.opts();
     this.sourceDir = path.resolve(this.options.sourceDir);
     this.localesDir = path.resolve(this.options.localesDir);
-    
+
     await this.validateSourceDir();
     await this.loadConfig();
   }
 
   async validateSourceDir() {
-    if (!fs.existsSync(this.sourceDir)) {
+    if (!SecurityUtils.safeExistsSync(this.sourceDir, path.dirname(this.sourceDir))) {
       console.error(`❌ Source directory not found: ${this.sourceDir}`);
       process.exit(1);
     }
@@ -137,16 +137,17 @@ class I18ntkJavaScriptCommand {
     if (this.options.vue) return 'vue';
     if (this.options.angular) return 'angular';
     if (this.options.node) return 'node';
-    
+
     console.log('🔍 Detecting JavaScript framework...');
-    
+
     let framework = 'generic';
 
     try {
       const packageJsonPath = path.join(this.sourceDir, 'package.json');
-      if (fs.existsSync(packageJsonPath)) {
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-        
+      if (SecurityUtils.safeExistsSync(packageJsonPath, this.sourceDir)) {
+        const packageJsonContent = SecurityUtils.safeReadFileSync(packageJsonPath, this.sourceDir, 'utf8');
+        const packageJson = SecurityUtils.safeParseJSON(packageJsonContent);
+
         const dependencies = {
           ...packageJson.dependencies || {},
           ...packageJson.devDependencies || {}
@@ -183,72 +184,72 @@ class I18ntkJavaScriptCommand {
   findFiles(pattern, extensions = []) {
     const results = [];
     const validExtensions = extensions.length > 0 ? extensions : ['.js', '.jsx', '.ts', '.tsx'];
-    
+
     function scanDir(dir) {
-      if (!fs.existsSync(dir)) return;
-      
+      if (!SecurityUtils.safeExistsSync(dir, path.dirname(dir))) return;
+
       const items = fs.readdirSync(dir);
       for (const item of items) {
         const fullPath = path.join(dir, item);
         const stat = fs.statSync(fullPath);
-        
+
         if (stat.isDirectory()) {
           // Skip node_modules and hidden directories
           if (item === 'node_modules' || item.startsWith('.')) continue;
-          
+
           // Skip test directories unless explicitly included
-          if (!this.options.includeTests && 
+          if (!this.options.includeTests &&
               (item === '__tests__' || item === 'test' || item === 'tests' || item.includes('.test.'))) {
             continue;
           }
-          
+
           scanDir.call(this, fullPath);
         } else {
           // Check file extension
           const ext = path.extname(item);
           if (validExtensions.includes(ext)) {
             // Skip test files unless explicitly included
-            if (!this.options.includeTests && 
+            if (!this.options.includeTests &&
                 (item.includes('.test.') || item.includes('.spec.') || item.includes('__test__'))) {
               continue;
             }
-            
+
             results.push(fullPath);
           }
         }
       }
     }
-    
+
     scanDir.call(this, this.sourceDir);
     return results;
   }
 
   async extractTranslations() {
     console.log('📦 Extracting JavaScript/TypeScript translations...');
-    
-    const extensions = this.options.typescript 
-      ? ['.js', '.jsx', '.ts', '.tsx'] 
+
+    const extensions = this.options.typescript
+      ? ['.js', '.jsx', '.ts', '.tsx']
       : ['.js', '.jsx'];
-    
+
     const jsFiles = this.findFiles('', extensions);
     const translations = new Set();
-    
+
     for (const file of jsFiles) {
       try {
-        const content = fs.readFileSync(file, 'utf8');
-        
+        const content = SecurityUtils.safeReadFileSync(file, path.dirname(file), 'utf8');
+
         for (const pattern of this.jsPatterns) {
           let match;
           while ((match = pattern.exec(content)) !== null) {
             translations.add(match[1]);
           }
         }
-        
+
         // Reset regex state for next file
         for (const pattern of this.jsPatterns) {
           pattern.lastIndex = 0;
         }
-        
+
       } catch (error) {
         if (this.options.debug) {
           console.error(`Error reading ${file}:`, error.message);
@@ -261,28 +262,28 @@ class I18ntkJavaScriptCommand {
   }
 
   async createLocaleStructure() {
-    if (!fs.existsSync(this.localesDir)) {
+    if (!SecurityUtils.safeExistsSync(this.localesDir, path.dirname(this.localesDir))) {
       if (this.options.dryRun) {
         console.log(`📁 Would create directory: ${this.localesDir}`);
         return;
       }
-      
+
       fs.mkdirSync(this.localesDir, { recursive: true });
       console.log(`📁 Created locales directory: ${this.localesDir}`);
     }
 
     const languages = ['en', 'es', 'fr', 'de', 'ja', 'ru', 'zh'];
-    
+
     for (const lang of languages) {
       const langDir = path.join(this.localesDir, lang);
-      if (!fs.existsSync(langDir)) {
+      if (!SecurityUtils.safeExistsSync(langDir, this.localesDir)) {
         if (this.options.dryRun) {
           console.log(`📁 Would create directory: ${langDir}`);
           continue;
         }
-        
+
         fs.mkdirSync(langDir, { recursive: true });
-        
+
         // Create framework-specific translation files
         const commonFile = path.join(langDir, 'common.json');
         const initialContent = {
@@ -306,21 +307,21 @@ class I18ntkJavaScriptCommand {
             }
           }
         };
-        
-        fs.writeFileSync(commonFile, JSON.stringify(initialContent, null, 2));
+
+        SecurityUtils.safeWriteFileSync(commonFile, JSON.stringify(initialContent, null, 2), this.localesDir);
       }
     }
   }
 
   async analyzeFramework(framework) {
     console.log(`🔍 Analyzing ${framework} project...`);
-    
-    const extensions = this.options.typescript 
-      ? ['.js', '.jsx', '.ts', '.tsx'] 
+
+    const extensions = this.options.typescript
+      ? ['.js', '.jsx', '.ts', '.tsx']
       : ['.js', '.jsx'];
-    
+
     const jsFiles = this.findFiles('', extensions);
-    
+
     const analysis = {
       framework,
       typescript: this.options.typescript || false,
@@ -358,14 +359,14 @@ class I18ntkJavaScriptCommand {
       else if (ext === '.ts') analysis.files.typescript++;
       else if (ext === '.jsx') analysis.files.jsx++;
       else if (ext === '.tsx') analysis.files.tsx++;
-      
+
       if (file.includes('.test.') || file.includes('.spec.')) {
         analysis.files.test++;
       }
 
       try {
-        const content = fs.readFileSync(file, 'utf8');
-        
+        const content = SecurityUtils.safeReadFileSync(file, path.dirname(file), 'utf8');
+
         // Check patterns
         if (content.includes('i18n.t(')) analysis.patterns.i18n_t++;
         if (content.includes('t(')) analysis.patterns.t_function++;
@@ -374,7 +375,7 @@ class I18ntkJavaScriptCommand {
         if (content.includes('translate')) analysis.patterns.translate++;
         if (content.includes('$t(')) analysis.patterns.$t++;
         if (content.includes('gettext(')) analysis.patterns.gettext++;
-        
+
         // Detect frameworks
         if (content.includes('import React') || content.includes('require("react")')) {
           analysis.frameworks.react = true;
@@ -388,7 +389,7 @@ class I18ntkJavaScriptCommand {
         if (content.includes('express') || content.includes('node')) {
           analysis.frameworks.node = true;
         }
-        
+
       } catch (error) {
         // Skip unreadable files
       }
@@ -398,11 +399,11 @@ class I18ntkJavaScriptCommand {
     if (analysis.files.total > 0 && analysis.patterns.i18n_t === 0) {
       analysis.recommendations.push('Consider adding i18n support to your JavaScript/TypeScript files');
     }
-    
+
     if (analysis.frameworks.react && analysis.patterns.FormattedMessage === 0) {
       analysis.recommendations.push('Consider using react-intl or react-i18next for React i18n');
     }
-    
+
     if (analysis.frameworks.vue && analysis.patterns.$t === 0) {
       analysis.recommendations.push('Consider using vue-i18n for Vue.js i18n');
     }
@@ -410,10 +411,11 @@ class I18ntkJavaScriptCommand {
     // Check package.json for dependencies
     try {
       const packageJsonPath = path.join(this.sourceDir, 'package.json');
-      if (fs.existsSync(packageJsonPath)) {
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      if (SecurityUtils.safeExistsSync(packageJsonPath, this.sourceDir)) {
+        const packageJsonContent = SecurityUtils.safeReadFileSync(packageJsonPath, this.sourceDir, 'utf8');
+        const packageJson = SecurityUtils.safeParseJSON(packageJsonContent);
         const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-        
+
         for (const [pkg, version] of Object.entries(deps)) {
           if (pkg.includes('i18n') || pkg.includes('intl') || pkg.includes('translate')) {
             analysis.dependencies.push(`${pkg}@${version}`);
@@ -455,12 +457,12 @@ class I18ntkJavaScriptCommand {
     };
 
     const reportPath = path.join(this.sourceDir, 'i18ntk-js-report.json');
-    
+
     if (this.options.dryRun) {
       console.log(`📊 Would create report: ${reportPath}`);
       console.log('📋 Report contents:', JSON.stringify(report, null, 2));
     } else {
-      fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+      SecurityUtils.safeWriteFileSync(reportPath, JSON.stringify(report, null, 2), this.sourceDir);
       console.log(`📊 Report saved: ${reportPath}`);
     }
 
@@ -469,19 +471,19 @@ class I18ntkJavaScriptCommand {
 
   async run() {
     try {
-      console.log('🚀 i18ntk JavaScript/TypeScript Command v1.10.1');
-      console.log('=' * 60);
-      
+      console.log('🚀 i18ntk JavaScript/TypeScript Command v1.10.1');
+      console.log('='.repeat(60));
+
       await this.init();
-      
+
       const framework = await this.detectFramework();
       const translations = await this.extractTranslations();
-      
+
       if (!this.options.extractOnly) {
         await this.createLocaleStructure();
         const analysis = await this.analyzeFramework(framework);
         const report = await this.generateReport(analysis, translations);
-        
+
         console.log('\n✅ Analysis complete!');
         console.log(`📊 Framework: ${framework}`);
         console.log(`📄 Total files: ${analysis.files.total}`);
@@ -490,7 +492,7 @@ class I18ntkJavaScriptCommand {
       } else {
         console.log(`📦 Extracted ${translations.length} translation keys`);
       }
-      
+
     } catch (error) {
       console.error('❌ Error:', error.message);
       if (this.options.debug) {
@@ -507,4 +509,4 @@ if (require.main === module) {
   cmd.run();
 }
 
-module.exports = I18ntkJavaScriptCommand;
+module.exports = I18ntkJavaScriptCommand;

package/main/i18ntk-manage.js

@@ -18,11 +18,12 @@
  *   node i18ntk-manage.js --command=init
  */
 
-const fs = require('fs');
 const path = require('path');
 const UIi18n = require('./i18ntk-ui');
 const AdminAuth = require('../utils/admin-auth');
 const SecurityUtils = require('../utils/security');
+
+
 const AdminCLI = require('../utils/admin-cli');
 const configManager = require('../settings/settings-manager');
 const { showFrameworkWarningOnce } = require('../utils/cli-helper');
@@ -36,6 +37,8 @@ const SettingsCLI = require('../settings/settings-cli');
 // const I18nDebugger = require('../scripts/debug/debugger');
 const { createPrompt, isInteractive } = require('../utils/prompt-helper');
 const { loadTranslations, t, refreshLanguageFromSettings} = require('../utils/i18n-helper');
+// Preload translations early to avoid missing key warnings
+loadTranslations();
 const cliHelper = require('../utils/cli-helper');
 const { loadConfig, saveConfig, ensureConfigDefaults } = require('../utils/config');
 const pkg = require('../package.json');
@@ -50,10 +53,6 @@ async function runInitFlow() {
   return { i18nDir: settings.i18nDir, sourceDir: settings.sourceDir };
 }
 
-
-
-
-
 /**
  * Ensures the project is properly initialized or exits the process
  * @param {Object} prompt - Prompt interface for user interaction
@@ -129,7 +128,7 @@ async function ensureInitializedOrExit(prompt) {
       console.log('Framework detection prompt will be suppressed for this version.');
     } else if (action === 'detect') {
       // Run framework detection
-      const { detectedLanguage, detectedFramework } = detectEnvironmentAndFramework();
+      const { detectedLanguage, detectedFramework } = await detectEnvironmentAndFramework();
       
       if (detectedFramework && detectedFramework !== 'generic') {
         console.log(`\nDetected framework: ${detectedFramework}`);
@@ -156,7 +155,90 @@ async function ensureInitializedOrExit(prompt) {
   return { ...config, ...settings };
 }
 
+/**
+ * Custom glob implementation using Node.js built-in modules (zero dependencies)
+ * @param {string[]} patterns - Array of glob patterns
+ * @param {Object} options - Options object with cwd and ignore properties
+ * @returns {Promise<string[]>} Array of matching file paths
+ */
+async function customGlob(patterns, options = {}) {
+  const fs = require('fs');
+  const path = require('path');
+  const cwd = options.cwd || process.cwd();
+  const ignorePatterns = options.ignore || [];
+
+  function matchesPattern(filename, pattern) {
+    // Simple pattern matching for **/*.{js,jsx,ts,tsx} style patterns
+    if (pattern.includes('**/*')) {
+      const extensionPart = pattern.split('*.')[1];
+      if (extensionPart) {
+        const extensions = extensionPart.replace('{', '').replace('}', '').split(',');
+        return extensions.some(ext => filename.endsWith('.' + ext.trim()));
+      }
+    }
+    return filename.includes(pattern.replace('**/', ''));
+  }
+
+  function shouldIgnore(filePath) {
+    return ignorePatterns.some(pattern => {
+      if (pattern.includes('**/')) {
+        const patternEnd = pattern.replace('**/', '');
+        return filePath.includes('/' + patternEnd) || filePath.includes('\\' + patternEnd);
+      }
+      return filePath.includes(pattern);
+    });
+  }
+
+  function findFiles(dir, results = []) {
+    try {
+      const items = fs.readdirSync(dir);
+
+      for (const item of items) {
+        const fullPath = path.join(dir, item);
+        const relativePath = path.relative(cwd, fullPath);
+
+        if (shouldIgnore(relativePath)) {
+          continue;
+        }
+
+        try {
+          const stat = fs.statSync(fullPath);
+
+          if (stat.isDirectory()) {
+            findFiles(fullPath, results);
+          } else if (stat.isFile()) {
+            // Check if file matches any of our patterns
+            for (const pattern of patterns) {
+              if (matchesPattern(item, pattern)) {
+                results.push(relativePath);
+                break;
+              }
+            }
+          }
+        } catch (error) {
+          // Skip files we can't access
+          continue;
+        }
+      }
+    } catch (error) {
+      // Skip directories we can't access
+    }
+
+    return results;
+  }
+
+  return findFiles(cwd);
+}
+
 async function detectEnvironmentAndFramework() {
+  // Defensive check to ensure SecurityUtils is available
+  if (!SecurityUtils) {
+    throw new Error('SecurityUtils is not available. This may indicate a module loading issue.');
+  }
+  const fs = require('fs');
+  const path = require('path');
+  
+  
   const packageJsonPath = path.join(process.cwd(), 'package.json');
   const pyprojectPath = path.join(process.cwd(), 'pyproject.toml');
   const requirementsPath = path.join(process.cwd(), 'requirements.txt');
@@ -167,10 +249,10 @@ async function detectEnvironmentAndFramework() {
   let detectedLanguage = 'generic';
   let detectedFramework = 'generic';
 
-  if (fs.existsSync(packageJsonPath)) {
+  if (SecurityUtils.safeExistsSync(packageJsonPath)) {
     detectedLanguage = 'javascript';
     try {
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      const packageJson = JSON.parse(SecurityUtils.safeReadFileSync(packageJsonPath, path.dirname(packageJsonPath), 'utf8'));
       const deps = { 
         ...(packageJson.dependencies || {}), 
         ...(packageJson.devDependencies || {}),
@@ -189,7 +271,7 @@ async function detectEnvironmentAndFramework() {
           /require\(['\"]i18ntk[\/\\]runtime['\"]\)/
         ];
         
-        const sourceFiles = await glob(['src/**/*.{js,jsx,ts,tsx}'], {
+        const sourceFiles = await customGlob(['src/**/*.{js,jsx,ts,tsx}'], {
           cwd: process.cwd(),
           ignore: ['**/node_modules/**', '**/dist/**', '**/build/**']
         });
@@ -223,11 +305,11 @@ async function detectEnvironmentAndFramework() {
     } catch (error) {
       detectedFramework = 'generic';
     }
-  } else if (fs.existsSync(pyprojectPath) || fs.existsSync(requirementsPath)) {
+  } else if (SecurityUtils.safeExistsSync(pyprojectPath) || SecurityUtils.safeExistsSync(requirementsPath)) {
     detectedLanguage = 'python';
     try {
-      if (fs.existsSync(requirementsPath)) {
-        const requirements = fs.readFileSync(requirementsPath, 'utf8');
+      if (SecurityUtils.safeExistsSync(requirementsPath)) {
+        const requirements = SecurityUtils.safeReadFileSync(requirementsPath, path.dirname(requirementsPath), 'utf8');
         if (requirements.includes('django')) detectedFramework = 'django';
         else if (requirements.includes('flask')) detectedFramework = 'flask';
         else if (requirements.includes('fastapi')) detectedFramework = 'fastapi';
@@ -236,13 +318,13 @@ async function detectEnvironmentAndFramework() {
     } catch (error) {
       detectedFramework = 'generic';
     }
-  } else if (fs.existsSync(goModPath)) {
+  } else if (SecurityUtils.safeExistsSync(goModPath)) {
     detectedLanguage = 'go';
     detectedFramework = 'generic';
-  } else if (fs.existsSync(pomPath)) {
+  } else if (SecurityUtils.safeExistsSync(pomPath)) {
     detectedLanguage = 'java';
     try {
-      const pomContent = fs.readFileSync(pomPath, 'utf8');
+      const pomContent = SecurityUtils.safeReadFileSync(pomPath, path.dirname(pomPath), 'utf8');
       if (pomContent.includes('spring-boot')) detectedFramework = 'spring-boot';
       else if (pomContent.includes('spring')) detectedFramework = 'spring';
       else if (pomContent.includes('quarkus')) detectedFramework = 'quarkus';
@@ -250,10 +332,10 @@ async function detectEnvironmentAndFramework() {
     } catch (error) {
       detectedFramework = 'generic';
     }
-  } else if (fs.existsSync(composerPath)) {
+  } else if (SecurityUtils.safeExistsSync(composerPath)) {
     detectedLanguage = 'php';
     try {
-      const composer = JSON.parse(fs.readFileSync(composerPath, 'utf8'));
+      const composer = JSON.parse(SecurityUtils.safeReadFileSync(composerPath, path.dirname(composerPath), 'utf8'));
       const deps = composer.require || {};
       
       if (deps['laravel/framework']) detectedFramework = 'laravel';
@@ -461,7 +543,7 @@ class I18nManager {
     // Only auto-detect if no settings are configured
     for (const possiblePath of possibleI18nPaths) {
       const resolvedPath = path.resolve(projectRoot, possiblePath);
-      if (fs.existsSync(resolvedPath)) {
+      if (SecurityUtils.safeExistsSync(resolvedPath)) {
         // Check if it contains language directories
         try {
           const items = fs.readdirSync(resolvedPath);
@@ -487,13 +569,13 @@ class I18nManager {
   async checkI18nDependencies() {
     const packageJsonPath = path.resolve('./package.json');
     
-    if (!fs.existsSync(packageJsonPath)) {
+    if (!SecurityUtils.safeExistsSync(packageJsonPath)) {
       console.log(this.ui ? this.ui.t('errors.noPackageJson') : 'No package.json found');
       return false; // Treat as no framework detected
     }
     
     try {
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      const packageJson = JSON.parse(SecurityUtils.safeReadFileSync(packageJsonPath, path.dirname(packageJsonPath), 'utf8'));
       // Include peerDependencies in the check
       const dependencies = { 
         ...packageJson.dependencies, 
@@ -610,12 +692,29 @@ class I18nManager {
 
   // Add this run method after the checkI18nDependencies method
   async run() {
+    // Add timeout to prevent hanging
+    const args = this.parseArgs();
+
+    const timeout = setTimeout(() => {
+      console.error('❌ CLI startup timeout - something is hanging');
+      if (args.debug) {
+        console.error('🔍 DEBUG: Last known execution point reached');
+      }
+      process.exit(1);
+    }, 10000); // 10 second timeout
+
+    if (args.debug) {
+      console.log('🔍 DEBUG: Starting i18ntk-manage.js...');
+      console.log('🔍 DEBUG: Process.argv:', process.argv);
+      console.log('🔍 DEBUG: Parsed args:', args);
+      console.log('🔍 DEBUG: About to call SetupEnforcer.checkSetupCompleteAsync()');
+    }
+
     let prompt;
     try {
       // Ensure setup is complete before running any operations
       await SetupEnforcer.checkSetupCompleteAsync();
-      
-      const args = this.parseArgs();
+
       prompt = createPrompt({ noPrompt: args.noPrompt || Boolean(args.adminPin) });
       const interactive = isInteractive({ noPrompt: args.noPrompt || Boolean(args.adminPin) });
 
@@ -1186,7 +1285,7 @@ class I18nManager {
   console.log(t('debug.runningDebugTool', { displayName }));
     try {
       const toolPath = path.join(__dirname, '..', 'scripts', 'debug', toolName);
-      if (fs.existsSync(toolPath)) {
+      if (SecurityUtils.safeExistsSync(toolPath)) {
         console.log(`Debug tool available: ${toolName}`);
         console.log(`To run this tool manually: node "${toolPath}"`);
         console.log(`Working directory: ${path.join(__dirname, '..')}`);
@@ -1209,7 +1308,7 @@ class I18nManager {
     
     try {
       const logsDir = path.join(__dirname, '..', 'scripts', 'debug', 'logs');
-      if (fs.existsSync(logsDir)) {
+      if (SecurityUtils.safeExistsSync(logsDir)) {
         const files = fs.readdirSync(logsDir)
           .filter(file => file.endsWith('.log') || file.endsWith('.txt'))
           .sort((a, b) => {
@@ -1230,7 +1329,7 @@ class I18nManager {
           const fileIndex = parseInt(choice) - 1;
           
           if (fileIndex >= 0 && fileIndex < files.length) {
-            const logContent = fs.readFileSync(path.join(logsDir, files[fileIndex]), 'utf8');
+            const logContent = SecurityUtils.safeReadFileSync(path.join(logsDir, files[fileIndex]), logsDir, 'utf8');
             console.log(`\n${t('debug.contentOf', { filename: files[fileIndex] })}:`);
             console.log('============================================================');
             console.log(logContent.slice(-2000)); // Show last 2000 characters
@@ -1290,7 +1389,7 @@ class I18nManager {
       
       // Check which directories exist and have files
       for (const dir of targetDirs) {
-        if (fs.existsSync(dir.path)) {
+        if (SecurityUtils.safeExistsSync(dir.path)) {
           const files = this.getAllReportFiles(dir.path);
           if (files.length > 0) {
             availableDirs.push({
@@ -1429,7 +1528,7 @@ class I18nManager {
     let files = [];
     
     try {
-      if (!fs.existsSync(dir)) {
+      if (!SecurityUtils.safeExistsSync(dir)) {
         return [];
       }
       
@@ -1561,7 +1660,7 @@ if (require.main === module) {
   if (args.includes('--version') || args.includes('-v')) {
     try {
       const packageJsonPath = path.resolve(__dirname, '../package.json');
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      const packageJson = JSON.parse(SecurityUtils.safeReadFileSync(packageJsonPath, path.dirname(packageJsonPath), 'utf8'));
       const versionInfo = packageJson.versionInfo || {};
       
       console.log(`\n🌍 i18n Toolkit (i18ntk)`);
@@ -1592,4 +1691,4 @@ if (require.main === module) {
   manager.run();
 }
 
-module.exports = I18nManager;
+module.exports = I18nManager;