i18ntk 1.7.0 → 1.7.2

package/utils/cli-helper.js

@@ -129,17 +129,90 @@ function showFrameworkWarningOnce(ui) {
   if (frameworkWarningShown) return;
   frameworkWarningShown = true;
 
-  const t = ui && typeof ui.t === 'function' ? ui.t.bind(ui) : (key) => {
-    const messages = {
-      'init.suggestions.noFramework': 'No i18n framework detected. Consider using one of the following:',
-      'init.frameworks.react': ' - react-i18next',
-      'init.frameworks.vue': ' - vue-i18n',
-      'init.frameworks.i18next': ' - i18next',
-      'init.frameworks.nuxt': ' - @nuxtjs/i18n',
-      'init.frameworks.svelte': ' - svelte-i18n'
-    };
-    return messages[key] || key;
-  };
+  // Try to use the proper translation system first
+  let t;
+  if (ui && typeof ui.t === 'function') {
+    t = ui.t.bind(ui);
+  } else {
+    // Fallback to loading the UI i18n system properly
+    try {
+      const UIi18n = require('../main/i18ntk-ui');
+      const fallbackUI = new UIi18n();
+      fallbackUI.loadLanguage('en'); // Load English as fallback
+      t = fallbackUI.t.bind(fallbackUI);
+    } catch (error) {
+      // Last resort: use locale files directly
+      try {
+        const path = require('path');
+        const fs = require('fs');
+        const localePath = path.join(__dirname, '..', 'ui-locales', 'en.json');
+        if (fs.existsSync(localePath)) {
+          const translations = JSON.parse(fs.readFileSync(localePath, 'utf8'));
+          t = (key) => {
+            const keys = key.split('.');
+            let result = translations;
+            for (const k of keys) {
+              result = result && result[k];
+            }
+            return result || key;
+          };
+        } else {
+          throw new Error('Locale file not found');
+        }
+      } catch (fallbackError) {
+        // Final fallback: load from current UI locale or English
+        try {
+          const path = require('path');
+          const fs = require('fs');
+          
+          // Try to determine current language from settings
+          const settingsManager = require('../settings/settings-manager');
+          const settings = settingsManager.loadSettings();
+          const currentLang = settings.uiLanguage || 'en';
+          
+          const localePath = path.join(__dirname, '..', 'ui-locales', `${currentLang}.json`);
+          if (fs.existsSync(localePath)) {
+            const translations = JSON.parse(fs.readFileSync(localePath, 'utf8'));
+            t = (key) => {
+              const keys = key.split('.');
+              let result = translations;
+              for (const k of keys) {
+                result = result && result[k];
+              }
+              return result || key;
+            };
+          } else {
+            // Fallback to English
+            const enLocalePath = path.join(__dirname, '..', 'ui-locales', 'en.json');
+            if (fs.existsSync(enLocalePath)) {
+              const translations = JSON.parse(fs.readFileSync(enLocalePath, 'utf8'));
+              t = (key) => {
+                const keys = key.split('.');
+                let result = translations;
+                for (const k of keys) {
+                  result = result && result[k];
+                }
+                return result || key;
+              };
+            } else {
+              throw new Error('No locale files found');
+            }
+          }
+        } catch (finalError) {
+          // Absolute last resort: basic hardcoded fallback
+          const messages = {
+            'init.suggestions.noFramework': 'No i18n framework detected. Consider using one of the following:',
+            'init.frameworks.react': ' - React i18next (react-i18next)',
+            'init.frameworks.vue': ' - Vue i18n (vue-i18next)',
+            'init.frameworks.i18next': ' - i18next (i18next)',
+            'init.frameworks.nuxt': ' - Nuxt i18n (@nuxtjs/i18next)',
+            'init.frameworks.svelte': ' - Svelte i18n (svelte-i18next)'
+          };
+          t = (key) => messages[key] || key;
+        }
+      }
+    }
+  }
 
   console.log(t('init.suggestions.noFramework'));
   console.log(t('init.frameworks.react'));

package/utils/config-helper.js

@@ -64,6 +64,7 @@ async function getUnifiedConfig(scriptName, cliArgs = {}) {
       outputDir: configManager.toRelative(cfg.outputDir),
     };
 
+    const settingsDir = settingsManager.configDir;
     const config = {
       ...cfg,
       sourceLanguage: cliArgs.sourceLanguage || cfg.sourceLanguage || 'en',
@@ -73,10 +74,10 @@ async function getUnifiedConfig(scriptName, cliArgs = {}) {
       excludeFiles: cfg.excludeFiles || cfg.processing?.excludeFiles || ['.DS_Store', 'Thumbs.db'],
       excludeDirs: cfg.excludeDirs || cfg.processing?.excludeDirs || ['node_modules', '.next', '.git', 'dist', 'build'],
       strictMode: cliArgs.strictMode || cfg.strictMode || false,
-      backupDir: path.resolve(cfg.projectRoot, path.join('settings', 'backups')),
-    tempDir: path.resolve(cfg.projectRoot, path.join('settings', 'temp')),
-    cacheDir: path.resolve(cfg.projectRoot, path.join('settings', '.cache')),
-    configDir: path.resolve(cfg.projectRoot, 'settings'),
+      backupDir: path.join(settingsDir, 'backups'),
+      tempDir: path.join(settingsDir, 'temp'),
+      cacheDir: path.join(settingsDir, '.cache'),
+      configDir: settingsDir,
       settings: {
         defaultLanguages: cfg.defaultLanguages || ['de', 'es', 'fr', 'ru'],
         processing: { ...cfg.processing },
@@ -267,13 +268,42 @@ function displayPaths(cfg = {}) {
 // Ensure project has been initialized with source language files
 async function ensureInitialized(cfg) {
   try {
+    // Check if initialization has been marked as complete
+    const configPath = path.join(settingsManager.configDir, 'initialization.json');
+    let initStatus = { initialized: false, version: null, timestamp: null };
+    
+    if (fs.existsSync(configPath)) {
+      try {
+        initStatus = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        // If initialized and version matches current, skip further checks
+        if (initStatus.initialized && initStatus.version === '1.7.2') {
+          return true;
+        }
+      } catch (e) {
+        // Invalid initialization file, proceed with normal check
+      }
+    }
+
     const sourceDir = cfg.sourceDir;
     const sourceLanguage = cfg.sourceLanguage || 'en';
     const langDir = path.join(sourceDir, sourceLanguage);
 
-    const initialized = fs.existsSync(langDir) &&
+    const hasLanguageFiles = fs.existsSync(langDir) &&
       fs.readdirSync(langDir).some(f => f.endsWith('.json'));
-    if (initialized) return true;
+    
+    // If language files exist and we're upgrading, mark as initialized
+    if (hasLanguageFiles) {
+      const initDir = path.dirname(configPath);
+      ensureDirectory(initDir);
+      fs.writeFileSync(configPath, JSON.stringify({
+        initialized: true,
+        version: '1.7.2',
+        timestamp: new Date().toISOString(),
+        sourceDir: sourceDir,
+        sourceLanguage: sourceLanguage
+      }, null, 2));
+      return true;
+    }
 
     const nonInteractive = !process.stdin.isTTY;
     const initScript = path.join(__dirname, '..', 'main', 'i18ntk-init.js');
@@ -281,6 +311,18 @@ async function ensureInitialized(cfg) {
     if (nonInteractive) {
       console.warn(`Missing source language files in ${langDir}. Running initialization...`);
       const result = spawnSync(process.execPath, [initScript, '--yes', `--source-dir=${sourceDir}`, `--source-language=${sourceLanguage}`], { stdio: 'inherit', windowsHide: true });
+      if (result.status === 0) {
+        // Mark initialization as complete
+        const initDir = path.dirname(configPath);
+        ensureDirectory(initDir);
+        fs.writeFileSync(configPath, JSON.stringify({
+          initialized: true,
+          version: '1.7.2',
+          timestamp: new Date().toISOString(),
+          sourceDir: sourceDir,
+          sourceLanguage: sourceLanguage
+        }, null, 2));
+      }
       return result.status === 0;
     }
 
@@ -290,6 +332,18 @@ async function ensureInitialized(cfg) {
 
     if (answer.trim().toLowerCase().startsWith('y')) {
       const result = spawnSync(process.execPath, [initScript, `--source-dir=${sourceDir}`, `--source-language=${sourceLanguage}`], { stdio: 'inherit', windowsHide: true });
+      if (result.status === 0) {
+        // Mark initialization as complete
+        const initDir = path.dirname(configPath);
+        ensureDirectory(initDir);
+        fs.writeFileSync(configPath, JSON.stringify({
+          initialized: true,
+          version: '1.7.2',
+          timestamp: new Date().toISOString(),
+          sourceDir: sourceDir,
+          sourceLanguage: sourceLanguage
+        }, null, 2));
+      }
       return result.status === 0;
     }
     return false;

package/utils/config-manager.js

@@ -3,7 +3,8 @@ const path = require('path');
 
 // Project root is where commands are executed
 const projectRoot = process.cwd();
-const CONFIG_DIR = path.join(projectRoot, 'settings');
+const settingsManager = require('../settings/settings-manager');
+const CONFIG_DIR = settingsManager.configDir;
 const CONFIG_PATH = path.join(CONFIG_DIR, 'i18ntk-config.json');
 
 // Default configuration values - comprehensive configuration

package/utils/config.js

@@ -0,0 +1,41 @@
+const fs = require('fs');
+const path = require('path');
+
+const settingsManager = require('../settings/settings-manager');
+const CONFIG_FILE = 'i18ntk-config.json';
+
+function getConfigPath(cwd = settingsManager.configDir) {
+  return path.join(cwd, CONFIG_FILE);
+}
+
+function loadConfig(cwd = settingsManager.configDir) {
+  const p = getConfigPath(cwd);
+  try {
+    const raw = fs.readFileSync(p, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function saveConfig(cfg, cwd = settingsManager.configDir) {
+  const dir = cwd;
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, CONFIG_FILE), JSON.stringify(cfg, null, 2), 'utf8');
+}
+
+function ensureConfigDefaults(cfg = {}) {
+  return {
+    initialized: cfg.initialized ?? false,
+    i18nDir: cfg.i18nDir ?? null,
+    sourceDir: cfg.sourceDir ?? null,
+    framework: {
+      detected: cfg.framework && cfg.framework.detected != null ? cfg.framework.detected : null,
+      preference: cfg.framework && cfg.framework.preference != null ? cfg.framework.preference : 'none',
+      prompt: cfg.framework && cfg.framework.prompt != null ? cfg.framework.prompt : 'always',
+      lastPromptedVersion: cfg.framework && cfg.framework.lastPromptedVersion != null ? cfg.framework.lastPromptedVersion : null
+    }
+  };
+}
+
+module.exports = { getConfigPath, loadConfig, saveConfig, ensureConfigDefaults };

package/utils/i18n-helper.js

@@ -125,7 +125,8 @@ function loadTranslations(language) {
   const settings = cfg?.getConfig?.() || {};
   const configuredLanguage = settings.uiLanguage || settings.language || 'en';
 
-  const requested = (language || configuredLanguage || 'en').toString();
+  // Prioritize settings file language over environment variable
+  const requested = (configuredLanguage || language || 'en').toString();
   const short = requested.split('-')[0].toLowerCase();
   const tryOrder = [requested, short, 'en'];
 

package/utils/promptPin.js

@@ -0,0 +1,76 @@
+const readline = require('readline');
+
+async function promptPin({ rl, label = 'Enter 4-digit Admin PIN: ', length = 4, digitsOnly = true } = {}) {
+  return rawMaskedPrompt(rl, label, { length, digitsOnly });
+}
+
+async function promptPinConfirm(rl, label1 = 'Enter new 4-digit Admin PIN: ', label2 = 'Confirm PIN: ') {
+  const pin1 = await promptPin({ rl, label: label1 });
+  const pin2 = await promptPin({ rl, label: label2 });
+  if (pin1 !== pin2) throw new Error('PINs do not match');
+  return pin1;
+}
+
+function rawMaskedPrompt(rl, promptText, { length = 4, digitsOnly = true } = {}) {
+  return new Promise((resolve) => {
+    const input = rl.input;
+    const output = rl.output;
+
+    const isRaw = input.isRaw;
+    if (!isRaw) input.setRawMode && input.setRawMode(true);
+
+    let buf = '';
+
+    const onData = (chunk) => {
+      const s = chunk.toString('utf8');
+
+      if (s === '\r' || s === '\n') {
+        if (buf.length === length) {
+          output.write('\n');
+          cleanup();
+          return resolve(buf);
+        }
+        return;
+      }
+
+      if (s === '\u0003') {
+        output.write('\n');
+        cleanup();
+        process.exit(130);
+      }
+
+      if (s === '\u0008' || s === '\u007f') {
+        if (buf.length > 0) buf = buf.slice(0, -1);
+        repaint();
+        return;
+      }
+
+      const ch = s;
+      if (digitsOnly) {
+        if (/^\d$/.test(ch) && buf.length < length) {
+          buf += ch;
+          repaint();
+        }
+      } else if (buf.length < length) {
+        buf += ch;
+        repaint();
+      }
+    };
+
+    const repaint = () => {
+      output.cursorTo && output.cursorTo(0);
+      output.clearLine && output.clearLine(1);
+      output.write(promptText + '*'.repeat(buf.length));
+    };
+
+    const cleanup = () => {
+      input.removeListener('data', onData);
+      if (!isRaw) input.setRawMode && input.setRawMode(false);
+    };
+
+    output.write(promptText);
+    input.on('data', onData);
+  });
+}
+
+module.exports = { promptPin, promptPinConfirm };

package/utils/security-check.js

@@ -20,8 +20,12 @@ class SecurityChecker {
      * Check if we should suppress output (e.g., during npm install)
      */
     shouldBeSilent() {
-        // Check if we're running in silent mode or specific contexts
-        return this.isSilent;
+        // Determine silent mode based on environment variables
+        return (
+            process.env.npm_config_loglevel === 'silent' ||
+            process.env.I18NTK_SILENT === 'true' ||
+            process.env.CI === 'true'
+        );
     }
 
     /**

package/utils/security.js

@@ -356,7 +356,7 @@ class SecurityUtils {
   static async saveEncryptedPin(pin) {
     try {
       const hash = crypto.createHash('sha256').update(pin).digest('hex');
-      const settingsDir = path.join(process.cwd(), 'settings');
+      const settingsDir = require('../settings/settings-manager').configDir;
       const pinFile = path.join(settingsDir, 'admin-pin.hash');
       await fs.promises.mkdir(settingsDir, { recursive: true });
       await fs.promises.writeFile(pinFile, hash, 'utf8');