@scoutello/i18n-magic 0.59.1 → 0.61.0

package/src/cli.ts

@@ -3,7 +3,7 @@ import dotenv from "dotenv"
 import OpenAI from "openai"
 import { checkMissing } from "./commands/check-missing.js"
 import { removeUnusedKeys } from "./commands/clean.js"
-
+import { removeKey } from "./commands/remove-key.js"
 import { replaceTranslation } from "./commands/replace.js"
 import { restoreFromNamespaces } from "./commands/restore-from-namespaces.js"
 import { translateMissing } from "./commands/scan.js"
@@ -59,12 +59,18 @@ const commands: CommandType[] = [
       "Restore missing keys by searching for them in other namespace files across all locales.",
     action: restoreFromNamespaces,
   },
+  {
+    name: "remove-key",
+    description:
+      "Remove a specific translation key from all namespaces and locales.",
+    action: removeKey,
+  },
 ]
 
 for (const command of commands) {
   const cmd = program.command(command.name).description(command.description)
 
-  // Add key option to replace command
+  // Add key option to replace and remove-key commands
   if (command.name === "replace") {
     cmd
       .option("-k, --key <key>", "translation key to replace")
@@ -72,8 +78,15 @@ for (const command of commands) {
       .argument("[key]", "translation key to replace")
   }
 
+  if (command.name === "remove-key") {
+    cmd
+      .option("-k, --key <key>", "translation key to remove")
+      .allowExcessArguments(true)
+      .argument("[key]", "translation key to remove")
+  }
+
   cmd.action(async (arg, options) => {
-    const res = dotenv.config({
+    dotenv.config({
       path: program.opts().env || ".env",
     })
 
@@ -105,8 +118,8 @@ for (const command of commands) {
       }),
     })
 
-    // For replace command, check for key in argument or option
-    if (command.name === "replace") {
+    // For replace and remove-key commands, check for key in argument or option
+    if (command.name === "replace" || command.name === "remove-key") {
       // If key is provided as positional argument, use that first
       const keyToUse = typeof arg === "string" ? arg : options.key
       command.action({ ...config, openai }, keyToUse)

package/src/commands/remove-key.ts

@@ -0,0 +1,123 @@
+import prompts from "prompts"
+import type { Configuration } from "../lib/types.js"
+import { loadLocalesFile, writeLocalesFile } from "../lib/utils.js"
+
+export const removeKey = async (config: Configuration, key?: string) => {
+  const { namespaces, locales, loadPath, savePath } = config
+
+  if (!key) {
+    const response = await prompts({
+      type: "text",
+      name: "key",
+      message: "Enter the translation key to remove:",
+      validate: (value) => (value ? true : "Key cannot be empty"),
+      onState: (state) => {
+        if (state.aborted) {
+          process.nextTick(() => {
+            process.exit(0)
+          })
+        }
+      },
+    })
+
+    key = response.key
+  }
+
+  if (!key) {
+    console.log("\n❌ Operation cancelled. No key was provided.")
+    return
+  }
+
+  console.log(
+    `\n🔍 Searching for key "${key}" across all namespaces and locales...`,
+  )
+
+  const foundIn: Array<{ namespace: string; locale: string }> = []
+
+  for (const namespace of namespaces) {
+    for (const locale of locales) {
+      try {
+        const existingKeys = await loadLocalesFile(
+          loadPath,
+          locale,
+          namespace,
+          {
+            silent: true,
+          },
+        )
+
+        if (Object.hasOwn(existingKeys, key)) {
+          foundIn.push({ namespace, locale })
+        }
+      } catch {
+        // Skip if file doesn't exist or can't be read
+      }
+    }
+  }
+
+  if (foundIn.length === 0) {
+    console.log(`\n❌ Key "${key}" not found in any namespace or locale.`)
+    return
+  }
+
+  console.log(`\n⚠️  Key "${key}" found in ${foundIn.length} location(s):\n`)
+
+  const maxToShow = 20
+  const itemsToShow = foundIn.slice(0, maxToShow)
+
+  for (const { namespace, locale } of itemsToShow) {
+    console.log(`   • ${locale}:${namespace}`)
+  }
+
+  if (foundIn.length > maxToShow) {
+    console.log(`   ... and ${foundIn.length - maxToShow} more`)
+  }
+
+  console.log("")
+
+  const { confirmed } = await prompts({
+    type: "confirm",
+    name: "confirmed",
+    message: `Do you want to remove "${key}" from ${foundIn.length} location(s)?`,
+    initial: false,
+    onState: (state) => {
+      if (state.aborted) {
+        process.nextTick(() => {
+          process.exit(0)
+        })
+      }
+    },
+  })
+
+  if (!confirmed) {
+    console.log("\n❌ Operation cancelled. No keys were removed.")
+    return
+  }
+
+  console.log(`\n🗑️  Removing key "${key}"...`)
+
+  let removedCount = 0
+
+  for (const { namespace, locale } of foundIn) {
+    try {
+      const existingKeys = await loadLocalesFile(loadPath, locale, namespace, {
+        silent: true,
+      })
+
+      if (Object.hasOwn(existingKeys, key)) {
+        delete existingKeys[key]
+        await writeLocalesFile(savePath, locale, namespace, existingKeys)
+        removedCount++
+        console.log(`   ✓ Removed from ${locale}:${namespace}`)
+      }
+    } catch (error) {
+      console.error(
+        `   ✗ Failed to remove from ${locale}:${namespace}: ${error instanceof Error ? error.message : String(error)}`,
+      )
+    }
+  }
+
+  console.log(
+    `\n✅ Successfully removed key "${key}" from ${removedCount} location(s)`,
+  )
+}

package/src/lib/utils.ts

@@ -872,34 +872,78 @@ export const addTranslationKeys = async ({
   log(`⏱️  Codebase scan completed in ${scanTime.toFixed(2)}ms`)
 
   // Step 2: Determine namespaces for each key
-  const keyToNamespaces = new Map<string, Set<string>>()
+  // Resolution order:
+  // 1) Explicit namespace prefix (e.g. "dashboard:welcome")
+  // 2) Code usage scan matches
+  // 3) Existing key in default locale namespace files
+  // 4) Key prefix matching a namespace (e.g. "dashboard.title")
+  // 5) Default namespace fallback
+  const defaultLocaleKeysByNamespace = new Map<string, Record<string, string>>()
+  await Promise.all(
+    namespaces.map(async (namespace) => {
+      try {
+        const nsKeys = await loadLocalesFile(loadPath, defaultLocale, namespace, {
+          silent: true,
+        })
+        defaultLocaleKeysByNamespace.set(namespace, nsKeys)
+      } catch {
+        defaultLocaleKeysByNamespace.set(namespace, {})
+      }
+    }),
+  )
 
-  for (const { key, language = "en" } of keys) {
-    const affectedNamespaces: string[] = []
+  const preparedKeys = keys.map(({ key, value, language = "en" }) => {
+    const splitKey = key.split(":")
+    const hasExplicitNamespace =
+      splitKey.length > 1 && namespaces.includes(splitKey[0])
+    const normalizedKey = hasExplicitNamespace ? splitKey.slice(1).join(":") : key
+    const explicitNamespace = hasExplicitNamespace ? splitKey[0] : null
+    const foundNamespaces = new Set<string>()
 
-    // Find entries for this specific key
-    const keyEntries = keysWithNamespaces.filter(
-      (entry) =>
-        entry.key === key || entry.key === `${defaultNamespace}:${key}`,
-    )
+    if (explicitNamespace) {
+      foundNamespaces.add(explicitNamespace)
+    } else {
+      for (const entry of keysWithNamespaces) {
+        for (const namespace of entry.namespaces) {
+          const pureKey = getPureKey(
+            entry.key,
+            namespace,
+            namespace === defaultNamespace,
+          )
+          if (entry.key === normalizedKey || pureKey === normalizedKey) {
+            foundNamespaces.add(namespace)
+          }
+        }
+      }
 
-    // Collect unique namespaces where this key is used
-    const foundNamespaces = new Set<string>()
-    for (const entry of keyEntries) {
-      for (const ns of entry.namespaces) {
-        foundNamespaces.add(ns)
+      if (foundNamespaces.size === 0) {
+        for (const namespace of namespaces) {
+          const namespaceKeys = defaultLocaleKeysByNamespace.get(namespace) || {}
+          if (Object.hasOwn(namespaceKeys, normalizedKey)) {
+            foundNamespaces.add(namespace)
+          }
+        }
+      }
+
+      if (foundNamespaces.size === 0) {
+        const keyPrefix = normalizedKey.split(".")[0]
+        if (namespaces.includes(keyPrefix)) {
+          foundNamespaces.add(keyPrefix)
+        }
       }
     }
 
-    if (foundNamespaces.size > 0) {
-      affectedNamespaces.push(...Array.from(foundNamespaces))
-    } else {
-      // If the key is not found in the codebase, use the default namespace
-      affectedNamespaces.push(defaultNamespace)
+    if (foundNamespaces.size === 0) {
+      foundNamespaces.add(defaultNamespace)
     }
 
-    keyToNamespaces.set(key, new Set(affectedNamespaces))
-  }
+    return {
+      key: normalizedKey,
+      value,
+      language,
+      namespaces: foundNamespaces,
+    }
+  })
 
   // Step 3: Group keys by namespace and locale
   const namespaceLocaleToKeys = new Map<
@@ -907,21 +951,24 @@ export const addTranslationKeys = async ({
     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}`
+  for (const keyEntry of preparedKeys) {
+    for (const namespace of keyEntry.namespaces) {
+      const mapKey = `${namespace}:${keyEntry.language}`
       if (!namespaceLocaleToKeys.has(mapKey)) {
         namespaceLocaleToKeys.set(mapKey, [])
       }
-      namespaceLocaleToKeys.get(mapKey)!.push({ key, value, language })
+      namespaceLocaleToKeys.get(mapKey)!.push({
+        key: keyEntry.key,
+        value: keyEntry.value,
+        language: keyEntry.language,
+      })
     }
   }
 
   // Step 4: Collect all unique namespaces that will be affected
   const affectedNamespaces = new Set<string>()
-  for (const namespaces of keyToNamespaces.values()) {
-    for (const ns of namespaces) {
+  for (const keyEntry of preparedKeys) {
+    for (const ns of keyEntry.namespaces) {
       affectedNamespaces.add(ns)
     }
   }
@@ -930,32 +977,31 @@ export const addTranslationKeys = async ({
   // This ensures we preserve existing keys in all locales
   const fileIOStartTime = performance.now()
   const localeFiles = new Map<string, Record<string, string>>()
+  const originalKeyCounts = new Map<string, number>()
   const loadErrors: Array<{ fileKey: string; error: string }> = []
 
-  // Load files for all locales × all affected namespaces - SEQUENTIALLY to avoid race conditions
+  // Load files for all locales × all affected namespaces in parallel (read-only)
+  const localeLoadPromises: Promise<void>[] = []
   for (const namespace of affectedNamespaces) {
     for (const locale of config.locales) {
       const fileKey = `${locale}:${namespace}`
-
-      if (!localeFiles.has(fileKey)) {
-        try {
-          const existingKeys = await loadLocalesFile(
-            loadPath,
-            locale,
-            namespace,
-            { silent: true },
-          )
-          localeFiles.set(fileKey, existingKeys)
-        } catch (error) {
-          // Don't silently ignore - track the error and DO NOT set empty object
-          const errorMsg =
-            error instanceof Error ? error.message : String(error)
-          loadErrors.push({ fileKey, error: errorMsg })
-          log(`⚠️  Failed to load ${fileKey}: ${errorMsg}`)
-        }
-      }
+      localeLoadPromises.push(
+        loadLocalesFile(loadPath, locale, namespace, { silent: true })
+          .then((existingKeys) => {
+            localeFiles.set(fileKey, existingKeys)
+            originalKeyCounts.set(fileKey, Object.keys(existingKeys).length)
+          })
+          .catch((error) => {
+            // Don't silently ignore - track the error and DO NOT set empty object
+            const errorMsg =
+              error instanceof Error ? error.message : String(error)
+            loadErrors.push({ fileKey, error: errorMsg })
+            log(`⚠️  Failed to load ${fileKey}: ${errorMsg}`)
+          }),
+      )
     }
   }
+  await Promise.all(localeLoadPromises)
 
   // If any files failed to load, abort to prevent data loss
   if (loadErrors.length > 0) {
@@ -992,14 +1038,14 @@ export const addTranslationKeys = async ({
       Array<{ key: string; value: string; namespaces: Set<string> }>
     >()
 
-    for (const { key, value, language = "en" } of keys) {
-      if (!keysByLanguage.has(language)) {
-        keysByLanguage.set(language, [])
+    for (const keyEntry of preparedKeys) {
+      if (!keysByLanguage.has(keyEntry.language)) {
+        keysByLanguage.set(keyEntry.language, [])
       }
-      keysByLanguage.get(language)!.push({
-        key,
-        value,
-        namespaces: keyToNamespaces.get(key) || new Set([defaultNamespace]),
+      keysByLanguage.get(keyEntry.language)!.push({
+        key: keyEntry.key,
+        value: keyEntry.value,
+        namespaces: keyEntry.namespaces,
       })
     }
 
@@ -1078,22 +1124,6 @@ export const addTranslationKeys = async ({
   // Step 8: Validate and write all files
   // Safety check: ensure we're not accidentally removing keys (only adding)
   const writeStartTime = performance.now()
-  const originalKeyCounts = new Map<string, number>()
-
-  // Store original key counts for validation
-  for (const namespace of affectedNamespaces) {
-    for (const locale of config.locales) {
-      const fileKey = `${locale}:${namespace}`
-      try {
-        const original = await loadLocalesFile(loadPath, locale, namespace, {
-          silent: true,
-        })
-        originalKeyCounts.set(fileKey, Object.keys(original).length)
-      } catch {
-        originalKeyCounts.set(fileKey, 0)
-      }
-    }
-  }
 
   // Validate: new file should have at least as many keys as original
   for (const [fileKey, newKeys] of localeFiles) {
@@ -1123,10 +1153,8 @@ export const addTranslationKeys = async ({
   )
 
   // Build results
-  const results = keys.map(({ key, value, language = "en" }) => {
-    const namespaces = Array.from(
-      keyToNamespaces.get(key) || new Set([defaultNamespace]),
-    )
+  const results = preparedKeys.map(({ key, value, language, namespaces }) => {
+    const resolvedNamespaces = Array.from(namespaces)
     const savedLocales = new Set<string>([language])
 
     if (openai) {
@@ -1143,7 +1171,7 @@ export const addTranslationKeys = async ({
     return {
       key,
       value,
-      namespace: namespaces.join(", "),
+      namespace: resolvedNamespaces.join(", "),
       locale: Array.from(savedLocales).sort().join(", "),
     }
   })