@scoutello/i18n-magic 0.51.0 → 0.53.0

package/src/commands/replace.ts

@@ -55,8 +55,14 @@ export const replaceTranslation = async (
     { namespace: string; value: string }[]
   > = {}
 
-  for (const namespace of namespaces) {
-    const keys = await loadLocalesFile(loadPath, defaultLocale, namespace)
+  const namespaceKeysResults = await Promise.all(
+    namespaces.map(async (namespace) => ({
+      namespace,
+      keys: await loadLocalesFile(loadPath, defaultLocale, namespace),
+    }))
+  )
+
+  for (const { namespace, keys } of namespaceKeysResults) {
     for (const [keyName, value] of Object.entries(keys)) {
       if (!allAvailableKeys[keyName]) {
         allAvailableKeys[keyName] = []
@@ -105,24 +111,32 @@ export const replaceTranslation = async (
   }
 
   // Show current translations across namespaces
-  for (const namespace of targetNamespaces) {
-    const keys = await loadLocalesFile(loadPath, defaultLocale, namespace)
-    if (keys[keyToReplace]) {
+  const currentTranslations = await Promise.all(
+    targetNamespaces.map(async (namespace) => {
+      const keys = await loadLocalesFile(loadPath, defaultLocale, namespace)
+      return { namespace, value: keys[keyToReplace] }
+    })
+  )
+
+  for (const { namespace, value } of currentTranslations) {
+    if (value) {
       console.log(
-        `Current translation in ${defaultLocale} (${namespace}): "${keys[keyToReplace]}"`,
+        `Current translation in ${defaultLocale} (${namespace}): "${value}"`,
       )
     }
   }
 
   const newTranslation = await getTextInput("Enter the new translation: ")
 
-  // Update the key in all relevant namespaces and locales
-  for (const namespace of targetNamespaces) {
-    for (const locale of locales) {
-      let newValue = ""
-      if (locale === defaultLocale) {
-        newValue = newTranslation
-      } else {
+  // Batch translate for all non-default locales first
+  const translationCache: Record<string, string> = {
+    [defaultLocale]: newTranslation,
+  }
+
+  const nonDefaultLocales = locales.filter((l) => l !== defaultLocale)
+  if (nonDefaultLocales.length > 0) {
+    await Promise.all(
+      nonDefaultLocales.map(async (locale) => {
         const translation = await translateKey({
           context,
           inputLanguage: defaultLocale,
@@ -133,17 +147,24 @@ export const replaceTranslation = async (
           openai,
           model: config.model,
         })
-
-        newValue = translation[keyToReplace]
-      }
-
-      const existingKeys = await loadLocalesFile(loadPath, locale, namespace)
-      existingKeys[keyToReplace] = newValue
-      await writeLocalesFile(savePath, locale, namespace, existingKeys)
-
-      console.log(
-        `Updated "${keyToReplace}" in ${locale} (${namespace}): "${newValue}"`,
-      )
-    }
+        translationCache[locale] = translation[keyToReplace]
+      })
+    )
   }
+
+  // Update the key in all relevant namespaces and locales in parallel
+  await Promise.all(
+    targetNamespaces.flatMap((namespace) =>
+      locales.map(async (locale) => {
+        const newValue = translationCache[locale]
+        const existingKeys = await loadLocalesFile(loadPath, locale, namespace)
+        existingKeys[keyToReplace] = newValue
+        await writeLocalesFile(savePath, locale, namespace, existingKeys)
+
+        console.log(
+          `Updated "${keyToReplace}" in ${locale} (${namespace}): "${newValue}"`,
+        )
+      })
+    )
+  )
 }

package/src/commands/scan.ts

@@ -3,7 +3,6 @@ import {
   checkAllKeysExist,
   getMissingKeys,
   getTextInput,
-  findExistingTranslation,
   findExistingTranslations,
   loadLocalesFile,
   translateKey,
@@ -93,40 +92,51 @@ export const translateMissing = async (config: Configuration) => {
 
   const allLocales = disableTranslationDuringScan ? [defaultLocale] : locales
 
-  for (const locale of allLocales) {
-    let translatedValues = {}
+  // Batch translate for all non-default locales in parallel
+  const translationCache: Record<string, Record<string, string>> = {
+    [defaultLocale]: newKeysObject,
+  }
 
-    if (locale === defaultLocale) {
-      translatedValues = newKeysObject
-    } else {
-      translatedValues = await translateKey({
-        inputLanguage: defaultLocale,
-        outputLanguage: locale,
-        context,
-        object: newKeysObject,
-        openai,
-        model: config.model,
+  const nonDefaultLocales = allLocales.filter((l) => l !== defaultLocale)
+  if (nonDefaultLocales.length > 0) {
+    await Promise.all(
+      nonDefaultLocales.map(async (locale) => {
+        const translatedValues = await translateKey({
+          inputLanguage: defaultLocale,
+          outputLanguage: locale,
+          context,
+          object: newKeysObject,
+          openai,
+          model: config.model,
+        })
+        translationCache[locale] = translatedValues
       })
-    }
+    )
+  }
 
-    for (const namespace of namespaces) {
-      const existingKeys = await loadLocalesFile(loadPath, locale, namespace)
+  // Process all locale/namespace combinations in parallel
+  await Promise.all(
+    allLocales.flatMap((locale) =>
+      namespaces.map(async (namespace) => {
+        const existingKeys = await loadLocalesFile(loadPath, locale, namespace)
 
-      const relevantKeys = newKeysWithDefaultLocale.filter((key) =>
-        key.namespaces?.includes(namespace),
-      )
+        const relevantKeys = newKeysWithDefaultLocale.filter((key) =>
+          key.namespaces?.includes(namespace),
+        )
 
-      if (relevantKeys.length === 0) {
-        continue
-      }
+        if (relevantKeys.length === 0) {
+          return
+        }
 
-      for (const key of relevantKeys) {
-        existingKeys[key.key] = translatedValues[key.key]
-      }
+        const translatedValues = translationCache[locale]
+        for (const key of relevantKeys) {
+          existingKeys[key.key] = translatedValues[key.key]
+        }
 
-      writeLocalesFile(savePath, locale, namespace, existingKeys)
-    }
-  }
+        await writeLocalesFile(savePath, locale, namespace, existingKeys)
+      })
+    )
+  )
 
   await checkAllKeysExist(config)
 

package/src/lib/utils.ts

@@ -703,45 +703,24 @@ export const addTranslationKey = async ({
 }) => {
   const { loadPath, savePath, defaultNamespace, namespaces, globPatterns, defaultLocale, openai, context, model } = config
 
-  // Use console.error for logging when called from MCP server (console.log is suppressed)
-  const log = console.log
-
-  // Validate that config has required fields
-  if (!loadPath || !savePath) {
-    throw new Error("Config must have loadPath and savePath defined")
-  }
-
-  if (!namespaces || namespaces.length === 0) {
-    throw new Error("Config must have at least one namespace defined")
-  }
-
   // Try to find which namespaces this key is used in by scanning the codebase
   const affectedNamespaces: string[] = []
   
   try {
-    log(`🔍 Scanning codebase for key "${key}"...`)
-    log(`   Glob patterns: ${extractGlobPatterns(globPatterns).length} pattern(s)`)
-    log(`   Default namespace: ${defaultNamespace}`)
-    
     // Scan the codebase to find where this key is already being used
     const keysWithNamespaces = await getKeysWithNamespaces({
       globPatterns,
       defaultNamespace,
     })
 
-    log(`   Scanned ${keysWithNamespaces.length} total key instances across all files`)
-
     // Find entries for this specific key
     const keyEntries = keysWithNamespaces.filter(
-      (entry) => entry.key === key || entry.key === `${defaultNamespace}:${key}` || entry.key.endsWith(`:${key}`)
+      (entry) => entry.key === key || entry.key === `${defaultNamespace}:${key}`
     )
 
-    log(`   Found ${keyEntries.length} instance(s) of key "${key}"`)
-
     // Collect unique namespaces where this key is used
     const foundNamespaces = new Set<string>()
     for (const entry of keyEntries) {
-      log(`      File: ${entry.file} → Namespaces: ${entry.namespaces.join(", ")}`)
       for (const ns of entry.namespaces) {
         foundNamespaces.add(ns)
       }
@@ -749,25 +728,19 @@ export const addTranslationKey = async ({
 
     if (foundNamespaces.size > 0) {
       affectedNamespaces.push(...Array.from(foundNamespaces))
-      log(
-        `✓ Found key "${key}" in use across ${affectedNamespaces.length} namespace(s): ${affectedNamespaces.join(", ")}`
+      console.log(
+        `🔍 Found key "${key}" in use across ${affectedNamespaces.length} namespace(s): ${affectedNamespaces.join(", ")}`
       )
     }
   } catch (error) {
-    // If scanning fails, log the error with details but continue with fallback logic
-    log(`⚠️  Warning: Failed to scan codebase for key usage`)
-    if (error instanceof Error) {
-      log(`   Error: ${error.message}`)
-      if (error.stack) {
-        log(`   Stack trace: ${error.stack}`)
-      }
-    }
+    // If scanning fails, continue with fallback logic
+    console.error(`Warning: Failed to scan codebase for key usage: ${error}`)
   }
 
   if (affectedNamespaces.length === 0) {
     // If the key is not found in the codebase, use the default namespace
     affectedNamespaces.push(defaultNamespace)
-    log(
+    console.log(
       `📝 Key "${key}" not found in codebase. Adding to default namespace "${defaultNamespace}".`
     )
   }
@@ -775,6 +748,9 @@ export const addTranslationKey = async ({
   // Always use "en" as the locale for adding keys (English)
   const locale = "en"
 
+  // Use console.error for logging when called from MCP server (console.log is suppressed)
+  const log = console.log
+
   for (const targetNamespace of affectedNamespaces) {
     log(`➕ Adding translation key "${key}" to namespace "${targetNamespace}" (${locale})`)
 
@@ -782,7 +758,6 @@ export const addTranslationKey = async ({
     let existingKeys: Record<string, string>
     try {
       existingKeys = await loadLocalesFile(loadPath, locale, targetNamespace)
-      log(`   Loaded ${Object.keys(existingKeys).length} existing keys from ${locale}/${targetNamespace}`)
     } catch (error) {
       // If file doesn't exist, start with empty object
       log(`📄 Creating new namespace file for ${locale}/${targetNamespace}`)
@@ -803,51 +778,39 @@ export const addTranslationKey = async ({
     log(`✅ Successfully saved key to ${locale}/${targetNamespace}`)
 
     // If defaultLocale is different from "en", translate and save to defaultLocale
-    if (defaultLocale !== "en") {
-      if (!openai) {
-        log(`⚠️  No OpenAI client configured. Skipping translation to ${defaultLocale}.`)
-        log(`   You can run 'i18n-magic sync' to translate this key later`)
-      } else if (!model) {
-        log(`⚠️  No model specified in config. Skipping translation to ${defaultLocale}.`)
-        log(`   You can run 'i18n-magic sync' to translate this key later`)
-      } else {
-        log(`🌐 Translating key "${key}" to ${defaultLocale}...`)
-        log(`   Using model: ${model}`)
-        
-        try {
-          // Translate the single key
-          const translatedValue = await translateKey({
-            inputLanguage: "en",
-            outputLanguage: defaultLocale,
-            context: context || "",
-            object: { [key]: value },
-            openai,
-            model: model as string,
-          })
-
-          // Load existing keys for the default locale
-          let defaultLocaleKeys: Record<string, string>
-          try {
-            defaultLocaleKeys = await loadLocalesFile(loadPath, defaultLocale, targetNamespace)
-          } catch (error) {
-            // If file doesn't exist, start with empty object
-            log(`📄 Creating new namespace file for ${defaultLocale}/${targetNamespace}`)
-            defaultLocaleKeys = {}
-          }
-
-          // Add the translated key
-          defaultLocaleKeys[key] = translatedValue[key]
+    if (defaultLocale !== "en" && openai) {
+      log(`🌐 Translating key "${key}" to ${defaultLocale}...`)
+      
+      try {
+        // Translate the single key
+        const translatedValue = await translateKey({
+          inputLanguage: "en",
+          outputLanguage: defaultLocale,
+          context: context || "",
+          object: { [key]: value },
+          openai,
+          model,
+        })
 
-          // Save the updated keys
-          await writeLocalesFile(savePath, defaultLocale, targetNamespace, defaultLocaleKeys)
-          log(`✅ Successfully translated and saved key to ${defaultLocale}/${targetNamespace}`)
+        // Load existing keys for the default locale
+        let defaultLocaleKeys: Record<string, string>
+        try {
+          defaultLocaleKeys = await loadLocalesFile(loadPath, defaultLocale, targetNamespace)
         } catch (error) {
-          log(`⚠️  Failed to translate key to ${defaultLocale}: ${error instanceof Error ? error.message : "Unknown error"}`)
-          if (error instanceof Error && error.stack) {
-            log(`   Stack: ${error.stack}`)
-          }
-          log(`   You can run 'i18n-magic sync' to translate this key later`)
+          // If file doesn't exist, start with empty object
+          log(`📄 Creating new namespace file for ${defaultLocale}/${targetNamespace}`)
+          defaultLocaleKeys = {}
         }
+
+        // Add the translated key
+        defaultLocaleKeys[key] = translatedValue[key]
+
+        // Save the updated keys
+        await writeLocalesFile(savePath, defaultLocale, targetNamespace, defaultLocaleKeys)
+        log(`✅ Successfully translated and saved key to ${defaultLocale}/${targetNamespace}`)
+      } catch (error) {
+        log(`⚠️  Failed to translate key to ${defaultLocale}: ${error instanceof Error ? error.message : "Unknown error"}`)
+        log(`   You can run 'i18n-magic sync' to translate this key later`)
       }
     }
   }