@scoutello/i18n-magic 0.53.0 → 0.55.0

package/src/lib/utils.ts

@@ -3,6 +3,7 @@ import { Parser } from "i18next-scanner"
 import { minimatch } from "minimatch"
 import fs from "node:fs"
 import path from "node:path"
+import { performance } from "node:perf_hooks"
 import type OpenAI from "openai"
 import prompts from "prompts"
 import { languages } from "./languges.js"
@@ -688,31 +689,53 @@ export class TranslationError extends Error {
 }
 
 /**
- * Add a translation key with an English value to the locale files.
- * This function always adds to the "en" locale, and if the defaultLocale is different,
- * it will also translate and save to the defaultLocale right away.
+ * Add a translation key with a value in a specific language to the locale files.
+ * This function adds to the specified language locale, and will also translate
+ * and save to other locales if OpenAI is configured.
  */
-export const addTranslationKey = async ({
-  key,
-  value,
+/**
+ * Add multiple translation keys in batch. This is optimized for performance:
+ * - Single codebase scan for all keys
+ * - Batched file I/O operations
+ * - Batched translations per locale
+ */
+export const addTranslationKeys = async ({
+  keys,
   config,
 }: {
-  key: string
-  value: string
+  keys: Array<{ key: string; value: string; language?: string }>
   config: Configuration
 }) => {
+  const startTime = performance.now()
   const { loadPath, savePath, defaultNamespace, namespaces, globPatterns, defaultLocale, openai, context, model } = config
 
-  // Try to find which namespaces this key is used in by scanning the codebase
-  const affectedNamespaces: string[] = []
-  
+  if (keys.length === 0) {
+    return { results: [], performance: { totalTime: 0, scanTime: 0, translationTime: 0, fileIOTime: 0 } }
+  }
+
+  const log = console.log
+  log(`🚀 Batch adding ${keys.length} translation key(s)...`)
+
+  // Step 1: Single codebase scan for all keys (most expensive operation)
+  const scanStartTime = performance.now()
+  let keysWithNamespaces: Array<{ key: string; namespaces: string[]; file: string }> = []
   try {
-    // Scan the codebase to find where this key is already being used
-    const keysWithNamespaces = await getKeysWithNamespaces({
+    keysWithNamespaces = await getKeysWithNamespaces({
       globPatterns,
       defaultNamespace,
     })
+  } catch (error) {
+    console.error(`Warning: Failed to scan codebase for key usage: ${error}`)
+  }
+  const scanTime = performance.now() - scanStartTime
+  log(`⏱️  Codebase scan completed in ${scanTime.toFixed(2)}ms`)
 
+  // Step 2: Determine namespaces for each key
+  const keyToNamespaces = new Map<string, Set<string>>()
+  
+  for (const { key, language = "en" } of keys) {
+    const affectedNamespaces: string[] = []
+    
     // Find entries for this specific key
     const keyEntries = keysWithNamespaces.filter(
       (entry) => entry.key === key || entry.key === `${defaultNamespace}:${key}`
@@ -728,97 +751,219 @@ export const addTranslationKey = async ({
 
     if (foundNamespaces.size > 0) {
       affectedNamespaces.push(...Array.from(foundNamespaces))
-      console.log(
-        `🔍 Found key "${key}" in use across ${affectedNamespaces.length} namespace(s): ${affectedNamespaces.join(", ")}`
-      )
+    } else {
+      // If the key is not found in the codebase, use the default namespace
+      affectedNamespaces.push(defaultNamespace)
     }
-  } catch (error) {
-    // 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)
-    console.log(
-      `📝 Key "${key}" not found in codebase. Adding to default namespace "${defaultNamespace}".`
-    )
+    keyToNamespaces.set(key, new Set(affectedNamespaces))
   }
 
-  // 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})`)
-
-    // Load existing keys for the English locale
-    let existingKeys: Record<string, string>
-    try {
-      existingKeys = await loadLocalesFile(loadPath, locale, targetNamespace)
-    } catch (error) {
-      // If file doesn't exist, start with empty object
-      log(`📄 Creating new namespace file for ${locale}/${targetNamespace}`)
-      existingKeys = {}
+  // Step 3: Group keys by namespace and locale
+  const namespaceLocaleToKeys = new Map<string, Array<{ key: string; value: string; language: string }>>()
+  
+  for (const { key, value, language = "en" } of keys) {
+    const namespaces = keyToNamespaces.get(key) || new Set([defaultNamespace])
+    for (const namespace of namespaces) {
+      const mapKey = `${namespace}:${language}`
+      if (!namespaceLocaleToKeys.has(mapKey)) {
+        namespaceLocaleToKeys.set(mapKey, [])
+      }
+      namespaceLocaleToKeys.get(mapKey)!.push({ key, value, language })
     }
+  }
 
-    // Check if key already exists
-    if (existingKeys[key]) {
-      log(`⚠️  Key "${key}" already exists in ${locale}/${targetNamespace} with value: "${existingKeys[key]}"`)
-      log(`   Updating to new value: "${value}"`)
+  // Step 4: Batch load all locale files needed
+  const fileIOStartTime = performance.now()
+  const localeFiles = new Map<string, Record<string, string>>()
+  const loadPromises: Promise<void>[] = []
+  
+  for (const [namespaceLocale, _] of namespaceLocaleToKeys) {
+    const [namespace, locale] = namespaceLocale.split(":")
+    const fileKey = `${locale}:${namespace}`
+    
+    if (!localeFiles.has(fileKey)) {
+      loadPromises.push(
+        loadLocalesFile(loadPath, locale, namespace)
+          .then((keys) => {
+            localeFiles.set(fileKey, keys)
+          })
+          .catch(() => {
+            localeFiles.set(fileKey, {})
+          })
+      )
     }
+  }
+  
+  await Promise.all(loadPromises)
+  const fileIOTime = performance.now() - fileIOStartTime
+  log(`⏱️  File I/O (load) completed in ${fileIOTime.toFixed(2)}ms`)
+
+  // Step 5: Add keys to loaded files
+  for (const [namespaceLocale, keyValues] of namespaceLocaleToKeys) {
+    const [namespace, locale] = namespaceLocale.split(":")
+    const fileKey = `${locale}:${namespace}`
+    const existingKeys = localeFiles.get(fileKey) || {}
+    
+    for (const { key, value } of keyValues) {
+      existingKeys[key] = value
+    }
+    
+    localeFiles.set(fileKey, existingKeys)
+  }
 
-    // Add or update the key
-    existingKeys[key] = value
-
-    // Save the updated keys using the writeLocalesFile function
-    await writeLocalesFile(savePath, locale, targetNamespace, existingKeys)
-    log(`✅ Successfully saved key to ${locale}/${targetNamespace}`)
+  // Step 6: Batch translate if OpenAI is configured
+  const translationStartTime = performance.now()
+  const translationCache = new Map<string, Record<string, string>>()
+  
+  if (openai) {
+    // Group keys by input language
+    const keysByLanguage = new Map<string, Array<{ key: string; value: string; namespaces: Set<string> }>>()
+    
+    for (const { key, value, language = "en" } of keys) {
+      if (!keysByLanguage.has(language)) {
+        keysByLanguage.set(language, [])
+      }
+      keysByLanguage.get(language)!.push({
+        key,
+        value,
+        namespaces: keyToNamespaces.get(key) || new Set([defaultNamespace]),
+      })
+    }
 
-    // If defaultLocale is different from "en", translate and save to defaultLocale
-    if (defaultLocale !== "en" && openai) {
-      log(`🌐 Translating key "${key}" to ${defaultLocale}...`)
+    // Translate each language group to all other locales
+    const translationPromises: Promise<void>[] = []
+    
+    for (const [inputLanguage, keyValues] of keysByLanguage) {
+      const otherLocales = config.locales.filter(l => l !== inputLanguage)
       
-      try {
-        // Translate the single key
-        const translatedValue = await translateKey({
-          inputLanguage: "en",
-          outputLanguage: defaultLocale,
-          context: context || "",
-          object: { [key]: value },
-          openai,
-          model,
-        })
-
-        // 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 = {}
+      for (const targetLocale of otherLocales) {
+        const keysToTranslate = Object.fromEntries(
+          keyValues.map(({ key, value }) => [key, value])
+        )
+        
+        translationPromises.push(
+          translateKey({
+            inputLanguage,
+            outputLanguage: targetLocale,
+            context: context || "",
+            object: keysToTranslate,
+            openai,
+            model,
+          })
+            .then((translated) => {
+              translationCache.set(`${inputLanguage}:${targetLocale}`, translated)
+            })
+            .catch((error) => {
+              log(`⚠️  Failed to translate ${keyValues.length} key(s) from ${inputLanguage} to ${targetLocale}: ${error instanceof Error ? error.message : "Unknown error"}`)
+            })
+        )
+      }
+    }
+    
+    await Promise.all(translationPromises)
+    
+    // Add translated keys to locale files
+    for (const [inputLanguage, keyValues] of keysByLanguage) {
+      const otherLocales = config.locales.filter(l => l !== inputLanguage)
+      
+      for (const targetLocale of otherLocales) {
+        const translated = translationCache.get(`${inputLanguage}:${targetLocale}`)
+        if (!translated) continue
+        
+        for (const { key, namespaces } of keyValues) {
+          if (translated[key]) {
+            for (const namespace of namespaces) {
+              const fileKey = `${targetLocale}:${namespace}`
+              if (!localeFiles.has(fileKey)) {
+                localeFiles.set(fileKey, {})
+              }
+              localeFiles.get(fileKey)![key] = translated[key]
+            }
+          }
         }
-
-        // 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`)
       }
     }
   }
+  
+  const translationTime = performance.now() - translationStartTime
+  if (openai && translationTime > 0) {
+    log(`⏱️  Translation completed in ${translationTime.toFixed(2)}ms`)
+  }
+
+  // Step 7: Batch write all files
+  const writeStartTime = performance.now()
+  const writePromises: Promise<void>[] = []
+  
+  for (const [fileKey, keys] of localeFiles) {
+    const [locale, namespace] = fileKey.split(":")
+    writePromises.push(
+      writeLocalesFile(savePath, locale, namespace, keys)
+    )
+  }
+  
+  await Promise.all(writePromises)
+  const writeTime = performance.now() - writeStartTime
+  log(`⏱️  File I/O (write) completed in ${writeTime.toFixed(2)}ms`)
+
+  const totalTime = performance.now() - startTime
+  log(`✅ Batch operation completed in ${totalTime.toFixed(2)}ms (${(totalTime / keys.length).toFixed(2)}ms per key)`)
+
+  // Build results
+  const results = keys.map(({ key, value, language = "en" }) => {
+    const namespaces = Array.from(keyToNamespaces.get(key) || new Set([defaultNamespace]))
+    const savedLocales = new Set<string>([language])
+    
+    if (openai) {
+      config.locales.forEach(locale => {
+        if (locale !== language) {
+          const translated = translationCache.get(`${language}:${locale}`)
+          if (translated?.[key]) {
+            savedLocales.add(locale)
+          }
+        }
+      })
+    }
+    
+    return {
+      key,
+      value,
+      namespace: namespaces.join(", "),
+      locale: Array.from(savedLocales).sort().join(", "),
+    }
+  })
 
   return {
-    key,
-    value,
-    namespace: affectedNamespaces.join(", "), // Return all affected namespaces
-    locale: defaultLocale !== "en" ? `en, ${defaultLocale}` : locale,
+    results,
+    performance: {
+      totalTime,
+      scanTime,
+      translationTime,
+      fileIOTime: fileIOTime + writeTime,
+    },
   }
 }
+
+export const addTranslationKey = async ({
+  key,
+  value,
+  language = "en",
+  config,
+}: {
+  key: string
+  value: string
+  language?: string
+  config: Configuration
+}) => {
+  const startTime = performance.now()
+  const result = await addTranslationKeys({
+    keys: [{ key, value, language }],
+    config,
+  })
+  const totalTime = performance.now() - startTime
+  
+  const log = console.log
+  log(`⏱️  Single key operation completed in ${totalTime.toFixed(2)}ms`)
+  
+  return result.results[0]
+}