@scoutello/i18n-magic 0.57.0 → 0.57.3

package/src/commands/sync-locales.ts

@@ -1,4 +1,6 @@
 import fs from "node:fs"
+import chalk from "chalk"
+import cliProgress from "cli-progress"
 import type { Configuration } from "../lib/types.js"
 import {
   TranslationError,
@@ -7,6 +9,12 @@ import {
   writeLocalesFile,
   findExistingTranslations,
 } from "../lib/utils.js"
+import { languages } from "../lib/languges.js"
+
+const getLanguageLabel = (locale: string): string => {
+  const lang = languages.find((l) => l.value === locale)
+  return lang?.label || locale
+}
 
 export const syncLocales = async (config: Configuration) => {
   const {
@@ -19,9 +27,59 @@ export const syncLocales = async (config: Configuration) => {
     openai,
   } = config
 
-  console.log(`🔄 Syncing translations for locales: ${locales.join(", ")}`)
-  console.log(`📦 Namespaces: ${namespaces.join(", ")}`)
-  console.log(`🌐 Default locale: ${defaultLocale}`)
+  const localesToProcess = locales.filter((l) => l !== defaultLocale)
+
+  console.log(chalk.cyan("\n🔄 Syncing translations\n"))
+  console.log(chalk.dim(`   Default locale: ${chalk.white(getLanguageLabel(defaultLocale))}`))
+  console.log(chalk.dim(`   Namespaces: ${chalk.white(namespaces.join(", "))}`))
+  console.log(chalk.dim(`   Target languages: ${chalk.white(localesToProcess.length)}\n`))
+
+  // Create multi-bar container
+  const multibar = new cliProgress.MultiBar(
+    {
+      clearOnComplete: false,
+      hideCursor: true,
+      format: (options, params, payload) => {
+        const lang = payload.language || "unknown"
+        const status = payload.status || ""
+        const bar = options.barCompleteString?.substring(0, Math.round(params.progress * options.barsize!)) || ""
+        const emptyBar = options.barIncompleteString?.substring(0, options.barsize! - bar.length) || ""
+        
+        // Color the bar based on progress
+        let coloredBar: string
+        if (params.progress >= 1) {
+          coloredBar = chalk.green(bar) + chalk.gray(emptyBar)
+        } else if (params.progress >= 0.5) {
+          coloredBar = chalk.yellow(bar) + chalk.gray(emptyBar)
+        } else {
+          coloredBar = chalk.cyan(bar) + chalk.gray(emptyBar)
+        }
+
+        const percentage = Math.round(params.progress * 100)
+        const paddedLang = lang.padEnd(12)
+        const paddedStatus = status.padEnd(20)
+        
+        return `   ${chalk.white(paddedLang)} ${coloredBar} ${chalk.dim(percentage.toString().padStart(3))}% ${chalk.dim(paddedStatus)}`
+      },
+      barCompleteChar: "█",
+      barIncompleteChar: "░",
+      barsize: 25,
+    },
+    cliProgress.Presets.shades_classic,
+  )
+
+  // Create a progress bar for each locale
+  const progressBars: Record<string, cliProgress.SingleBar> = {}
+  const localeStats: Record<string, { missing: number; reused: number; translated: number }> = {}
+
+  for (const locale of localesToProcess) {
+    const langLabel = getLanguageLabel(locale)
+    progressBars[locale] = multibar.create(100, 0, {
+      language: langLabel,
+      status: "Waiting...",
+    })
+    localeStats[locale] = { missing: 0, reused: 0, translated: 0 }
+  }
 
   try {
     // Helper to ensure a locale/namespace file exists before we add keys
@@ -34,7 +92,6 @@ export const syncLocales = async (config: Configuration) => {
           .replace("{{lng}}", locale)
           .replace("{{ns}}", namespace)
         if (!fs.existsSync(filePath)) {
-          console.log(`📄 Creating missing namespace file: ${filePath}`)
           await writeLocalesFile(savePath, locale, namespace, {})
         }
       }
@@ -48,181 +105,223 @@ export const syncLocales = async (config: Configuration) => {
     )
 
     // Process all non-default locales in parallel
-    const localesToProcess = locales.filter((l) => l !== defaultLocale)
-
     await Promise.all(
       localesToProcess.map(async (locale) => {
-        console.log(`\n🔍 Processing locale: ${locale}`)
-
-        // Ensure all namespace files for this locale exist before filling keys
-        await Promise.all(
-          namespaces.map((namespace) =>
-            ensureLocaleNamespaceFile(locale, namespace),
-          ),
-        )
-
-        // Collect all missing keys for this locale across all namespaces
-        const allMissingKeys: Record<
-          string,
-          { value: string; namespaces: string[] }
-        > = {}
-        const namespaceKeys: Record<string, Record<string, string>> = {}
-
-        // Load existing keys for all namespaces in parallel
-        const namespaceResults = await Promise.all(
-          namespaces.map(async (namespace) => {
-            const defaultLocaleKeys = await loadLocalesFile(
-              loadPath,
-              defaultLocale,
-              namespace,
-            )
-
-            const localeKeys = await loadLocalesFile(
-              loadPath,
-              locale,
-              namespace,
-            )
-
-            return {
-              namespace,
-              defaultLocaleKeys,
-              localeKeys,
-            }
-          }),
-        )
-
-        // Process results and collect missing keys
-        for (const result of namespaceResults) {
-          const { namespace, defaultLocaleKeys, localeKeys } = result
-          namespaceKeys[namespace] = localeKeys
-
-          // Check which keys from default locale are missing in current locale
-          for (const [key, value] of Object.entries(defaultLocaleKeys)) {
-            if (!localeKeys[key]) {
-              if (allMissingKeys[key]) {
-                // Key already exists, add this namespace to the list
-                allMissingKeys[key].namespaces.push(namespace)
-              } else {
-                // New missing key
-                allMissingKeys[key] = {
-                  value,
-                  namespaces: [namespace],
+        const bar = progressBars[locale]
+        const stats = localeStats[locale]
+
+        try {
+          // Stage 1: Loading (0-20%)
+          bar.update(5, { status: "Loading files..." })
+
+          // Ensure all namespace files for this locale exist before filling keys
+          await Promise.all(
+            namespaces.map((namespace) =>
+              ensureLocaleNamespaceFile(locale, namespace),
+            ),
+          )
+
+          bar.update(10, { status: "Analyzing keys..." })
+
+          // Collect all missing keys for this locale across all namespaces
+          const allMissingKeys: Record<
+            string,
+            { value: string; namespaces: string[] }
+          > = {}
+          const namespaceKeys: Record<string, Record<string, string>> = {}
+
+          // Load existing keys for all namespaces in parallel
+          const namespaceResults = await Promise.all(
+            namespaces.map(async (namespace) => {
+              const defaultLocaleKeys = await loadLocalesFile(
+                loadPath,
+                defaultLocale,
+                namespace,
+                { silent: true },
+              )
+
+              const localeKeys = await loadLocalesFile(
+                loadPath,
+                locale,
+                namespace,
+                { silent: true },
+              )
+
+              return {
+                namespace,
+                defaultLocaleKeys,
+                localeKeys,
+              }
+            }),
+          )
+
+          bar.update(20, { status: "Finding missing..." })
+
+          // Process results and collect missing keys
+          for (const result of namespaceResults) {
+            const { namespace, defaultLocaleKeys, localeKeys } = result
+            namespaceKeys[namespace] = localeKeys
+
+            // Check which keys from default locale are missing in current locale
+            for (const [key, value] of Object.entries(defaultLocaleKeys)) {
+              if (!localeKeys[key]) {
+                if (allMissingKeys[key]) {
+                  // Key already exists, add this namespace to the list
+                  allMissingKeys[key].namespaces.push(namespace)
+                } else {
+                  // New missing key
+                  allMissingKeys[key] = {
+                    value,
+                    namespaces: [namespace],
+                  }
                 }
               }
             }
           }
-        }
 
-        const missingKeysList = Object.keys(allMissingKeys)
-        if (missingKeysList.length === 0) {
-          console.log(`✅ No missing keys found for ${locale}`)
-          return
-        }
+          const missingKeysList = Object.keys(allMissingKeys)
+          stats.missing = missingKeysList.length
 
-        console.log(
-          `Found ${missingKeysList.length} unique missing keys in ${locale}`,
-        )
-
-        // Check for existing translations of these keys in other namespaces (parallelized)
-        const keysToTranslate: Record<string, string> = {}
-        const existingTranslations: Record<string, string> = {}
-
-        const existingTranslationResults = await findExistingTranslations(
-          missingKeysList,
-          namespaces,
-          locale,
-          loadPath,
-        )
-
-        const reusedKeys: string[] = []
-        for (const key of missingKeysList) {
-          const existingValue = existingTranslationResults[key]
-
-          // Use explicit null check instead of truthy check to handle empty string values
-          if (existingValue !== null) {
-            existingTranslations[key] = existingValue
-            reusedKeys.push(key)
-          } else {
-            keysToTranslate[key] = allMissingKeys[key].value
+          if (missingKeysList.length === 0) {
+            bar.update(100, { status: chalk.green("✓ Up to date") })
+            return
           }
-        }
 
-        // Batch log reused translations
-        if (reusedKeys.length > 0) {
-          console.log(
-            `🔄 Reusing ${reusedKeys.length} existing translations for ${locale}`,
-          )
-        }
+          // Stage 2: Check for existing translations (20-40%)
+          bar.update(25, { status: `Checking ${missingKeysList.length} keys...` })
 
-        let translatedValues: Record<string, string> = {}
+          const keysToTranslate: Record<string, string> = {}
+          const existingTranslations: Record<string, string> = {}
 
-        // Translate only the keys that don't have existing translations
-        if (Object.keys(keysToTranslate).length > 0) {
-          console.log(
-            `🔤 Translating ${Object.keys(keysToTranslate).length} new keys for ${locale}`,
+          const existingTranslationResults = await findExistingTranslations(
+            missingKeysList,
+            namespaces,
+            locale,
+            loadPath,
+            { silent: true },
           )
 
-          try {
-            translatedValues = await translateKey({
-              inputLanguage: defaultLocale,
-              outputLanguage: locale,
-              context,
-              object: keysToTranslate,
-              openai,
-              model: config.model,
-            })
-          } catch (error) {
-            throw new TranslationError(
-              `Failed to translate keys for locale "${locale}"`,
-              locale,
-              undefined,
-              error instanceof Error ? error : undefined,
-            )
+          bar.update(40, { status: "Processing results..." })
+
+          for (const key of missingKeysList) {
+            const existingValue = existingTranslationResults[key]
+
+            // Use explicit null check instead of truthy check to handle empty string values
+            if (existingValue !== null) {
+              existingTranslations[key] = existingValue
+              stats.reused++
+            } else {
+              keysToTranslate[key] = allMissingKeys[key].value
+            }
           }
-        }
 
-        // Combine existing translations with new translations
-        const allTranslations = { ...existingTranslations, ...translatedValues }
+          let translatedValues: Record<string, string> = {}
 
-        // Distribute translations to all relevant namespaces in parallel
-        await Promise.all(
-          namespaces.map(async (namespace) => {
-            let hasChanges = false
-            const updatedKeys = { ...namespaceKeys[namespace] }
+          // Stage 3: Translate (40-80%)
+          if (Object.keys(keysToTranslate).length > 0) {
+            const keysCount = Object.keys(keysToTranslate).length
+            bar.update(45, { status: `Translating ${keysCount} keys...` })
 
-            for (const key of missingKeysList) {
-              if (allMissingKeys[key].namespaces.includes(namespace)) {
-                const translation = allTranslations[key] || ""
-                updatedKeys[key] = translation
-                hasChanges = true
-              }
+            try {
+              translatedValues = await translateKey({
+                inputLanguage: defaultLocale,
+                outputLanguage: locale,
+                context,
+                object: keysToTranslate,
+                openai,
+                model: config.model,
+              })
+              stats.translated = Object.keys(translatedValues).length
+            } catch (error) {
+              bar.update(100, { status: chalk.red("✗ Translation failed") })
+              throw new TranslationError(
+                `Failed to translate keys for locale "${locale}"`,
+                locale,
+                undefined,
+                error instanceof Error ? error : undefined,
+              )
             }
+          }
 
-            if (hasChanges) {
-              try {
-                await writeLocalesFile(savePath, locale, namespace, updatedKeys)
-
-                const addedKeysCount = Object.keys(allMissingKeys).filter(
-                  (key) => allMissingKeys[key].namespaces.includes(namespace),
-                ).length
-
-                console.log(
-                  `✅ Updated ${locale} (${namespace}): ${addedKeysCount} keys`,
-                )
-              } catch (error) {
-                throw new TranslationError(
-                  `Failed to save translations for locale "${locale}" (namespace: ${namespace})`,
-                  locale,
-                  namespace,
-                  error instanceof Error ? error : undefined,
-                )
+          bar.update(80, { status: "Saving files..." })
+
+          // Stage 4: Save (80-100%)
+          // Combine existing translations with new translations
+          const allTranslations = { ...existingTranslations, ...translatedValues }
+
+          // Distribute translations to all relevant namespaces in parallel
+          await Promise.all(
+            namespaces.map(async (namespace) => {
+              let hasChanges = false
+              const updatedKeys = { ...namespaceKeys[namespace] }
+
+              for (const key of missingKeysList) {
+                if (allMissingKeys[key].namespaces.includes(namespace)) {
+                  const translation = allTranslations[key] || ""
+                  updatedKeys[key] = translation
+                  hasChanges = true
+                }
               }
-            }
-          }),
-        )
+
+              if (hasChanges) {
+                try {
+                  await writeLocalesFile(savePath, locale, namespace, updatedKeys)
+                } catch (error) {
+                  throw new TranslationError(
+                    `Failed to save translations for locale "${locale}" (namespace: ${namespace})`,
+                    locale,
+                    namespace,
+                    error instanceof Error ? error : undefined,
+                  )
+                }
+              }
+            }),
+          )
+
+          // Complete!
+          const statusMsg = stats.translated > 0 
+            ? chalk.green(`✓ +${stats.translated} translated`)
+            : chalk.green(`✓ ${stats.reused} reused`)
+          bar.update(100, { status: statusMsg })
+
+        } catch (error) {
+          if (error instanceof TranslationError) {
+            throw error
+          }
+          bar.update(100, { status: chalk.red("✗ Error") })
+          throw error
+        }
       }),
     )
+
+    // Stop the progress bars
+    multibar.stop()
+
+    // Print summary
+    console.log("")
+    console.log(chalk.green("✨ Sync complete!\n"))
+
+    // Show detailed stats
+    let totalMissing = 0
+    let totalReused = 0
+    let totalTranslated = 0
+
+    for (const locale of localesToProcess) {
+      const stats = localeStats[locale]
+      totalMissing += stats.missing
+      totalReused += stats.reused
+      totalTranslated += stats.translated
+    }
+
+    if (totalMissing > 0) {
+      console.log(chalk.dim("   Summary:"))
+      console.log(chalk.dim(`   • ${chalk.white(totalTranslated)} keys translated`))
+      console.log(chalk.dim(`   • ${chalk.white(totalReused)} keys reused from other namespaces`))
+      console.log("")
+    }
+
   } catch (error) {
+    multibar.stop()
     if (error instanceof TranslationError) {
       throw error
     }

package/src/lib/utils.ts

@@ -138,7 +138,10 @@ export const loadLocalesFile = async (
     | ((locale: string, namespace: string) => Promise<Record<string, string>>),
   locale: string,
   namespace: string,
+  options?: { silent?: boolean },
 ) => {
+  const silent = options?.silent ?? false
+
   if (typeof loadPath === "string") {
     const resolvedPath = loadPath
       .replace("{{lng}}", locale)
@@ -146,7 +149,9 @@ export const loadLocalesFile = async (
 
     // Check if file exists, return empty object if it doesn't
     if (!fs.existsSync(resolvedPath)) {
-      console.log(`📄 Creating new namespace file: ${resolvedPath}`)
+      if (!silent) {
+        console.log(`📄 Creating new namespace file: ${resolvedPath}`)
+      }
       return {}
     }
 
@@ -474,8 +479,10 @@ export const getMissingKeys = async ({
       `🔍 Checking ${keysForNamespace.size} keys for namespace ${namespace}`,
     )
 
+    const missingInNamespace: string[] = []
     for (const key of keysForNamespace) {
       if (!existingKeys[key]) {
+        missingInNamespace.push(key)
         if (uniqueMissingKeys.has(key)) {
           // Add this namespace to the existing entry
           const existing = uniqueMissingKeys.get(key)
@@ -496,6 +503,11 @@ export const getMissingKeys = async ({
         }
       }
     }
+
+    // Log missing keys for this namespace if any
+    if (missingInNamespace.length > 0) {
+      console.log(`   ❌ Missing in ${namespace}: ${missingInNamespace.slice(0, 10).join(", ")}${missingInNamespace.length > 10 ? `... and ${missingInNamespace.length - 10} more` : ""}`)
+    }
   }
 
   // Convert to the expected format
@@ -511,6 +523,17 @@ export const getMissingKeys = async ({
     })
   }
 
+  // Final summary of all missing keys
+  if (newKeys.length > 0) {
+    console.log(`\n📋 Summary: ${newKeys.length} unique missing key(s):`)
+    for (const { key, namespaces: ns } of newKeys.slice(0, 20)) {
+      console.log(`   - "${key}" in [${ns.join(", ")}]`)
+    }
+    if (newKeys.length > 20) {
+      console.log(`   ... and ${newKeys.length - 20} more`)
+    }
+  }
+
   return newKeys
 }
 
@@ -550,12 +573,16 @@ export const findExistingTranslations = async (
   loadPath:
     | string
     | ((locale: string, namespace: string) => Promise<Record<string, string>>),
+  options?: { silent?: boolean },
 ): Promise<Record<string, string | null>> => {
+  const silent = options?.silent ?? false
+  const log = silent ? () => {} : console.log
+
   // Load all namespace files in parallel first
   const namespaceKeys: Record<string, Record<string, string>> = {}
   const loadPromises = namespaces.map(async (namespace) => {
     try {
-      const existingKeys = await loadLocalesFile(loadPath, locale, namespace)
+      const existingKeys = await loadLocalesFile(loadPath, locale, namespace, { silent })
       namespaceKeys[namespace] = existingKeys
     } catch (error) {
       namespaceKeys[namespace] = {}
@@ -565,21 +592,21 @@ export const findExistingTranslations = async (
   await Promise.all(loadPromises)
 
   // Log how many keys were found in each namespace for the default locale
-  console.log(`\n🔎 Searching for existing translations in ${locale}:`)
+  log(`\n🔎 Searching for existing translations in ${locale}:`)
   for (const namespace of namespaces) {
     const nsKeys = Object.keys(namespaceKeys[namespace] || {})
-    console.log(`   📁 ${namespace}.json: ${nsKeys.length} keys available`)
+    log(`   📁 ${namespace}.json: ${nsKeys.length} keys available`)
     // Show sample keys from the namespace (first 3)
     if (nsKeys.length > 0) {
       const sampleKeys = nsKeys.slice(0, 3)
-      console.log(`      Sample keys: ${sampleKeys.join(", ")}${nsKeys.length > 3 ? "..." : ""}`)
+      log(`      Sample keys: ${sampleKeys.join(", ")}${nsKeys.length > 3 ? "..." : ""}`)
     }
   }
   
   // Show sample of keys we're searching for
   if (keys.length > 0) {
     const sampleSearchKeys = keys.slice(0, 3)
-    console.log(`\n   🔍 Looking for keys like: ${sampleSearchKeys.join(", ")}${keys.length > 3 ? "..." : ""}`)
+    log(`\n   🔍 Looking for keys like: ${sampleSearchKeys.join(", ")}${keys.length > 3 ? "..." : ""}`)
   }
 
   // Now find translations for all keys
@@ -612,14 +639,14 @@ export const findExistingTranslations = async (
     0,
   )
   const notFound = keys.length - totalFound
-  console.log(`\n📊 Search results for ${keys.length} missing keys:`)
+  log(`\n📊 Search results for ${keys.length} missing keys:`)
   for (const [namespace, count] of Object.entries(foundInNamespace)) {
-    console.log(`   ✅ Found ${count} keys in ${namespace}.json`)
+    log(`   ✅ Found ${count} keys in ${namespace}.json`)
   }
   if (notFound > 0) {
-    console.log(`   ❌ ${notFound} keys not found in any namespace`)
+    log(`   ❌ ${notFound} keys not found in any namespace`)
   }
-  console.log("")
+  log("")
 
   return results
 }

package/dist/commands/create-pruned-namespace-automated.d.ts

@@ -1,20 +0,0 @@
-import type { Configuration } from "../lib/types";
-export interface PruneOptions {
-    sourceNamespace: string;
-    newNamespace: string;
-    globPatterns: string[];
-}
-export interface PruneResult {
-    locale: string;
-    keyCount: number;
-    success: boolean;
-    error?: string;
-}
-export interface PruneResponse {
-    success: boolean;
-    message: string;
-    keysCount: number;
-    results?: PruneResult[];
-}
-export declare const createPrunedNamespaceAutomated: (config: Configuration, options: PruneOptions) => Promise<PruneResponse>;
-//# sourceMappingURL=create-pruned-namespace-automated.d.ts.map

package/dist/commands/create-pruned-namespace-automated.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-pruned-namespace-automated.d.ts","sourceRoot":"","sources":["../../src/commands/create-pruned-namespace-automated.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAQjD,MAAM,WAAW,YAAY;IAC3B,eAAe,EAAE,MAAM,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,EAAE,CAAA;CACvB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAA;CACxB;AAED,eAAO,MAAM,8BAA8B,GACzC,QAAQ,aAAa,EACrB,SAAS,YAAY,KACpB,OAAO,CAAC,aAAa,CAkIvB,CAAA"}