@scoutello/i18n-magic 0.15.2 → 0.18.0

package/src/commands/create-pruned-namespace-automated.ts

@@ -0,0 +1,165 @@
+import glob from "fast-glob"
+import { Parser } from "i18next-scanner"
+import fs from "node:fs"
+import type { Configuration } from "../lib/types"
+import {
+  getPureKey,
+  loadLocalesFile,
+  removeDuplicatesFromArray,
+  writeLocalesFile,
+} from "../lib/utils"
+
+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 const createPrunedNamespaceAutomated = async (
+  config: Configuration,
+  options: PruneOptions,
+): Promise<PruneResponse> => {
+  const { namespaces, loadPath, savePath, locales, defaultNamespace } = config
+  const { sourceNamespace, newNamespace, globPatterns } = options
+
+  // Validate inputs
+  if (!namespaces.includes(sourceNamespace)) {
+    throw new Error(
+      `Source namespace '${sourceNamespace}' not found in configuration`,
+    )
+  }
+
+  if (namespaces.includes(newNamespace)) {
+    throw new Error(`Namespace '${newNamespace}' already exists`)
+  }
+
+  console.log(
+    `Creating pruned namespace '${newNamespace}' from '${sourceNamespace}'`,
+  )
+  console.log(`Using glob patterns: ${globPatterns.join(", ")}`)
+
+  // Extract keys from files matching the glob patterns
+  const parser = new Parser({
+    nsSeparator: false,
+    keySeparator: false,
+  })
+
+  const files = await glob([...globPatterns, "!**/node_modules/**"])
+  console.log(`Found ${files.length} files to scan`)
+
+  const extractedKeys = []
+
+  for (const file of files) {
+    const content = fs.readFileSync(file, "utf-8")
+    parser.parseFuncFromString(content, { list: ["t"] }, (key: string) => {
+      extractedKeys.push(key)
+    })
+  }
+
+  const uniqueExtractedKeys = removeDuplicatesFromArray(extractedKeys)
+  console.log(`Found ${uniqueExtractedKeys.length} unique translation keys`)
+
+  // Filter keys that belong to the source namespace
+  const relevantKeys = []
+
+  for (const key of uniqueExtractedKeys) {
+    const pureKey = getPureKey(
+      key,
+      sourceNamespace,
+      sourceNamespace === defaultNamespace,
+    )
+
+    if (pureKey) {
+      relevantKeys.push(pureKey)
+    }
+  }
+
+  console.log(
+    `Found ${relevantKeys.length} keys from namespace '${sourceNamespace}'`,
+  )
+
+  if (relevantKeys.length === 0) {
+    console.log("No relevant keys found. Exiting...")
+    return {
+      success: false,
+      message: "No relevant keys found",
+      keysCount: 0,
+    }
+  }
+
+  // Get translations from source namespace and create new namespace files
+  const results: PruneResult[] = []
+
+  for (const locale of locales) {
+    try {
+      // Load source namespace translations
+      const sourceTranslations = await loadLocalesFile(
+        loadPath,
+        locale,
+        sourceNamespace,
+      )
+
+      // Create new namespace with only the keys used in the glob pattern files
+      const newNamespaceTranslations: Record<string, string> = {}
+
+      for (const key of relevantKeys) {
+        if (sourceTranslations[key]) {
+          newNamespaceTranslations[key] = sourceTranslations[key]
+        }
+      }
+
+      // Write the new namespace file
+      await writeLocalesFile(
+        savePath,
+        locale,
+        newNamespace,
+        newNamespaceTranslations,
+      )
+
+      const keyCount = Object.keys(newNamespaceTranslations).length
+      console.log(
+        `Created pruned namespace '${newNamespace}' for locale '${locale}' with ${keyCount} keys`,
+      )
+
+      results.push({
+        locale,
+        keyCount,
+        success: true,
+      })
+    } catch (error) {
+      console.error(
+        `Error creating pruned namespace for locale '${locale}':`,
+        error,
+      )
+      results.push({
+        locale,
+        keyCount: 0,
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }
+
+  console.log(`✅ Successfully created pruned namespace '${newNamespace}'`)
+
+  return {
+    success: true,
+    message: `Created pruned namespace '${newNamespace}' with ${relevantKeys.length} keys`,
+    keysCount: relevantKeys.length,
+    results,
+  }
+}

package/src/commands/create-pruned-namespace.ts

@@ -0,0 +1,165 @@
+import glob from "fast-glob"
+import { Parser } from "i18next-scanner"
+import fs from "node:fs"
+import prompts from "prompts"
+import type { Configuration } from "../lib/types"
+import {
+  getPureKey,
+  loadLocalesFile,
+  removeDuplicatesFromArray,
+  writeLocalesFile,
+} from "../lib/utils"
+
+export const createPrunedNamespace = async (config: Configuration) => {
+  const { namespaces, loadPath, savePath, locales, defaultNamespace } = config
+
+  // Step 1: Ask for source namespace
+  const sourceNamespaceResponse = await prompts({
+    type: "select",
+    name: "value",
+    message: "Select source namespace to create pruned version from:",
+    choices: namespaces.map((namespace) => ({
+      title: namespace,
+      value: namespace,
+    })),
+    onState: (state) => {
+      if (state.aborted) {
+        process.nextTick(() => {
+          process.exit(0)
+        })
+      }
+    },
+  })
+
+  const sourceNamespace = sourceNamespaceResponse.value
+
+  // Step 2: Ask for new namespace name
+  const newNamespaceResponse = await prompts({
+    type: "text",
+    name: "value",
+    message: "Enter the name for the new namespace:",
+    validate: (value) => {
+      if (!value) return "Namespace name cannot be empty"
+      if (namespaces.includes(value)) return "Namespace already exists"
+      return true
+    },
+    onState: (state) => {
+      if (state.aborted) {
+        process.nextTick(() => {
+          process.exit(0)
+        })
+      }
+    },
+  })
+
+  const newNamespace = newNamespaceResponse.value
+
+  // Step 3: Ask for glob patterns to find relevant keys
+  const globPatternsResponse = await prompts({
+    type: "list",
+    name: "value",
+    message: "Enter glob patterns to find relevant keys (comma separated):",
+    initial: config.globPatterns.join(","),
+    separator: ",",
+    onState: (state) => {
+      if (state.aborted) {
+        process.nextTick(() => {
+          process.exit(0)
+        })
+      }
+    },
+  })
+
+  const selectedGlobPatterns = globPatternsResponse.value
+
+  console.log(
+    `Finding keys used in files matching: ${selectedGlobPatterns.join(", ")}`,
+  )
+
+  // Extract keys from files matching the glob patterns
+  const parser = new Parser({
+    nsSeparator: false,
+    keySeparator: false,
+  })
+
+  const files = await glob([...selectedGlobPatterns, "!**/node_modules/**"])
+  console.log(`Found ${files.length} files to scan`)
+
+  const extractedKeys = []
+
+  for (const file of files) {
+    const content = fs.readFileSync(file, "utf-8")
+    parser.parseFuncFromString(content, { list: ["t"] }, (key: string) => {
+      extractedKeys.push(key)
+    })
+  }
+
+  const uniqueExtractedKeys = removeDuplicatesFromArray(extractedKeys)
+  console.log(`Found ${uniqueExtractedKeys.length} unique translation keys`)
+
+  // Filter keys that belong to the source namespace
+  const relevantKeys = []
+
+  for (const key of uniqueExtractedKeys) {
+    const pureKey = getPureKey(
+      key,
+      sourceNamespace,
+      sourceNamespace === defaultNamespace,
+    )
+
+    if (pureKey) {
+      relevantKeys.push(pureKey)
+    }
+  }
+
+  console.log(
+    `Found ${relevantKeys.length} keys from namespace '${sourceNamespace}'`,
+  )
+
+  if (relevantKeys.length === 0) {
+    console.log("No relevant keys found. Exiting...")
+    return
+  }
+
+  // Get translations from source namespace and create new namespace files
+  for (const locale of locales) {
+    try {
+      // Load source namespace translations
+      const sourceTranslations = await loadLocalesFile(
+        loadPath,
+        locale,
+        sourceNamespace,
+      )
+
+      // Create new namespace with only the keys used in the glob pattern files
+      const newNamespaceTranslations: Record<string, string> = {}
+
+      for (const key of relevantKeys) {
+        if (sourceTranslations[key]) {
+          newNamespaceTranslations[key] = sourceTranslations[key]
+        }
+      }
+
+      // Write the new namespace file
+      await writeLocalesFile(
+        savePath,
+        locale,
+        newNamespace,
+        newNamespaceTranslations,
+      )
+
+      console.log(
+        `Created pruned namespace '${newNamespace}' for locale '${locale}' with ${
+          Object.keys(newNamespaceTranslations).length
+        } keys`,
+      )
+    } catch (error) {
+      console.error(
+        `Error creating pruned namespace for locale '${locale}':`,
+        error,
+      )
+    }
+  }
+
+  console.log(`✅ Successfully created pruned namespace '${newNamespace}'`)
+}

package/src/commands/scan.ts

@@ -1,3 +1,4 @@
+import console from "console"
 import type { Configuration } from "../lib/types"
 import {
   checkAllKeysExist,
@@ -7,6 +8,7 @@ import {
   translateKey,
   writeLocalesFile,
 } from "../lib/utils"
+import { removeUnusedKeys } from "./clean"
 
 export const translateMissing = async (config: Configuration) => {
   const {
@@ -18,8 +20,18 @@ export const translateMissing = async (config: Configuration) => {
     context,
     openai,
     disableTranslation,
+    autoClear,
   } = config
 
+  // Run clean command first if autoClear is enabled
+  if (autoClear) {
+    console.log("🧹 Auto-clearing unused translations before scanning...")
+    await removeUnusedKeys(config)
+    console.log(
+      "✅ Auto-clear completed. Now scanning for missing translations...\n",
+    )
+  }
+
   const newKeys = await getMissingKeys(config)
 
   if (newKeys.length === 0) {

package/src/index.ts

@@ -1,106 +1,23 @@
-import { Command } from "commander"
-import dotenv from "dotenv"
-import OpenAI from "openai"
-import { checkMissing } from "./commands/check-missing"
-import { replaceTranslation } from "./commands/replace"
-import { translateMissing } from "./commands/scan"
-import { syncLocales } from "./commands/sync-locales"
-import type { CommandType, Configuration } from "./lib/types"
-import { loadConfig } from "./lib/utils"
-
-// Only run CLI initialization when this file is executed directly
-
-const program = new Command()
-
-program
-  .name("i18n-magic")
-  .description(
-    "CLI to help you manage your locales JSON with translations, replacements, etc. with OpenAI.",
-  )
-  .version("0.2.0")
-  .option("-c, --config <path>", "path to config file")
-  .option("-e, --env <path>", "path to .env file")
-
-const commands: CommandType[] = [
-  {
-    name: "scan",
-    description:
-      "Scan for missing translations, get prompted for each, translate it to the other locales and save it to the JSON file.",
-    action: translateMissing,
-  },
-  {
-    name: "replace",
-    description:
-      "Replace a translation based on the key, and translate it to the other locales and save it to the JSON file.",
-    action: replaceTranslation,
-  },
-  {
-    name: "check-missing",
-    description:
-      "Check if there are any missing translations. Useful for a CI/CD pipeline or husky hook.",
-    action: checkMissing,
-  },
-  {
-    name: "sync",
-    description:
-      "Sync the translations from the default locale to the other locales. Useful for a CI/CD pipeline or husky hook.",
-    action: syncLocales,
-  },
-]
-
-for (const command of commands) {
-  const cmd = program.command(command.name).description(command.description)
-
-  // Add key option to replace command
-  if (command.name === "replace") {
-    cmd
-      .option("-k, --key <key>", "translation key to replace")
-      .allowExcessArguments(true)
-      .argument("[key]", "translation key to replace")
-  }
-
-  cmd.action(async (arg, options) => {
-    const res = dotenv.config({
-      path: program.opts().env || ".env",
-    })
-
-    const config: Configuration = await loadConfig({
-      configPath: program.opts().config,
-    })
-
-    const isGemini = (config.model as string)?.includes("gemini")
-
-    // Get API key from environment or config
-    const openaiKey = res.parsed.OPENAI_API_KEY || config.OPENAI_API_KEY
-    const geminiKey = res.parsed.GEMINI_API_KEY || config.GEMINI_API_KEY
-
-    // Select appropriate key based on model type
-    const key = isGemini ? geminiKey : openaiKey
-
-    if (!key) {
-      const keyType = isGemini ? "GEMINI_API_KEY" : "OPENAI_API_KEY"
-      console.error(
-        `Please provide a${isGemini ? " Gemini" : "n OpenAI"} API key in your .env file or config, called ${keyType}.`,
-      )
-      process.exit(1)
-    }
-
-    const openai = new OpenAI({
-      apiKey: key,
-      ...(isGemini && {
-        baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/",
-      }),
-    })
-
-    // For replace command, check for key in argument or option
-    if (command.name === "replace") {
-      // If key is provided as positional argument, use that first
-      const keyToUse = typeof arg === "string" ? arg : options.key
-      command.action({ ...config, openai }, keyToUse)
-    } else {
-      command.action({ ...config, openai })
-    }
-  })
-}
-
-program.parse(process.argv)
+// Export command functions for programmatic usage
+export { checkMissing } from "./commands/check-missing"
+export { removeUnusedKeys } from "./commands/clean"
+export { createPrunedNamespace } from "./commands/create-pruned-namespace"
+export { createPrunedNamespaceAutomated } from "./commands/create-pruned-namespace-automated"
+export { replaceTranslation } from "./commands/replace"
+export { translateMissing } from "./commands/scan"
+export { syncLocales } from "./commands/sync-locales"
+
+// Export utility functions
+export { loadConfig } from "./lib/utils"
+
+// Export types
+export type {
+  PruneOptions,
+  PruneResponse,
+  PruneResult,
+} from "./commands/create-pruned-namespace-automated"
+export type {
+  CommandType,
+  Configuration,
+  NamespacePruneConfig,
+} from "./lib/types"

package/src/lib/types.ts

@@ -7,6 +7,12 @@ type Model =
   | "gemini-2.0-flash"
   | "gemini-2.0-flash-lite"
 
+export interface NamespacePruneConfig {
+  sourceNamespace: string
+  newNamespace: string
+  globPatterns: string[]
+}
+
 export interface Configuration {
   loadPath:
     | string
@@ -25,10 +31,12 @@ export interface Configuration {
   globPatterns: string[]
   context?: string
   disableTranslation?: boolean
+  autoClear?: boolean
   OPENAI_API_KEY?: string
   GEMINI_API_KEY?: string
   model?: Model
   openai?: OpenAI
+  pruneNamespaces?: NamespacePruneConfig[]
 }
 
 export interface CommandType {