i18nizer 0.6.2 → 0.7.1

package/README.md

@@ -13,16 +13,44 @@
 
 ---
 
-**i18nizer** is a developer-first CLI that **extracts translatable strings from JSX/TSX files**, automatically generates **i18n JSON files**, and **rewrites your components to use `t()`**.
+**i18nizer automates the boring parts of i18n.**
 
-It is designed to be fast, scriptable, CI-friendly, and completely **independent from your project configuration**.
+If your project already uses **i18next** or **next-intl**, i18nizer:
 
-### Supported AI Providers
+- extracts hardcoded strings from JSX/TSX
+- generates i18n JSON files using **AI-assisted translations**
+- creates readable English keys (**AI-powered & cached**)
+- rewrites your components to use `t("key")`
+
+No runtime, no lock-in, no SaaS.  
+Just a CLI that fits into your existing development workflow.
+
+## 🤖 How translations work
+
+i18nizer uses AI providers (OpenAI, Gemini, Hugging Face) to generate translations
+at development time.
+
+- Translations are generated once and stored as plain JSON files
+- Output is fully editable and version-controlled
+- No AI is required at runtime
+- Cached translations avoid repeated AI requests
+
+You own the result — i18nizer only automates the process.
+
+## Who is this for?
+
+- React / Next.js developers already using i18next or next-intl
+- Teams tired of manually extracting strings and managing i18n JSONs
+- Projects that want automation without changing runtime behavior
+
+## Supported AI Providers
 
 - **OpenAI**
 - **Google Gemini**
 - **Hugging Face (DeepSeek)**
 
+      Used for development-time translations and key generation.
+
 ---
 
 ## 🚀 Installation
@@ -62,6 +90,7 @@ i18nizer start
 ```
 
 This launches an **interactive setup** that will:
+
 - 🔍 Auto-detect your framework (Next.js or React)
 - 🔍 Auto-detect your i18n library (next-intl, react-i18next, i18next)
 - ❓ Ask you to confirm or change the detected settings
@@ -93,6 +122,7 @@ i18nizer start --framework custom --i18n custom
 ```
 
 **Available options:**
+
 - `--framework`: `nextjs`, `react`, `custom`
 - `--i18n`: `next-intl`, `react-i18next`, `i18next`, `custom`
 - `--yes`, `-y`: Skip interactive prompts
@@ -133,6 +163,7 @@ i18nizer regenerate
 ```
 
 This command regenerates the `i18n/messages.generated.ts` file by scanning all JSON files in your messages directory. Use this when:
+
 - You manually add or remove translation JSON files
 - You rename JSON files
 - The aggregator becomes out of sync with your messages
@@ -251,6 +282,68 @@ Legacy standalone mode (without `i18nizer start`):
 
 ## ⚙️ Configuration
 
+The `i18nizer.config.yml` file controls all aspects of how i18nizer processes your project. Here's a complete reference:
+
+### Complete Configuration Reference
+
+```yaml
+# Framework and i18n library settings
+framework: react                    # nextjs | react | custom
+i18nLibrary: react-i18next          # next-intl | react-i18next | i18next | custom
+
+# AI provider configuration
+ai:
+  provider: openai                  # openai | gemini | huggingface
+  model: gpt-4                      # AI model to use for translations
+
+# Directory paths
+paths:
+  src: src                          # Source code directory
+  i18n: i18n                        # i18n output directory
+
+# i18n function configuration
+i18n:
+  function: t                       # Translation function name
+  import:
+    source: react-i18next           # Package to import from
+    named: useTranslation           # Named import
+
+# Translation file settings
+messages:
+  path: messages                    # Where to store translation JSON files
+  defaultLocale: en                 # Default locale
+  locales:                          # List of supported locales
+    - en
+    - es
+  format: json                      # Output format (currently only json)
+
+# Behavior settings
+behavior:
+  detectDuplicates: true            # Reuse keys for duplicate strings across components
+  opinionatedStructure: true        # Use opinionated file structure
+  autoInjectT: true                 # Auto-inject translation hooks (disable for Next.js Server Components)
+  useAiForKeys: true                # Use AI to generate English keys
+  allowedFunctions:                 # Functions whose string arguments should be translated
+    - alert
+    - confirm
+    - prompt
+  allowedMemberFunctions:           # Member functions whose string arguments should be translated
+    - toast.error
+    - toast.info
+    - toast.success
+    - toast.warn
+  allowedProps:                     # JSX props that should be translated
+    - alt
+    - aria-label
+    - aria-placeholder
+    - helperText
+    - label
+    - placeholder
+    - text
+    - title
+    - tooltip
+```
+
 ### Translation Function Injection (`autoInjectT`)
 
 i18nizer can automatically inject translation hooks into your components:
@@ -262,6 +355,7 @@ const t = useTranslations("ComponentName");
 This behavior is controlled by `behavior.autoInjectT` in `i18nizer.config.yml`:
 
 **Next.js Projects** (disabled by default):
+
 ```yaml
 behavior:
   autoInjectT: false  # Disabled to avoid breaking Server Components
@@ -272,6 +366,7 @@ behavior:
 - You manually add the translation hook where appropriate
 
 **React Projects** (enabled by default):
+
 ```yaml
 behavior:
   autoInjectT: true  # Safe for Client Components
@@ -281,6 +376,7 @@ behavior:
 - Works seamlessly with React components
 
 **Why disabled for Next.js?**
+
 - Automatically detecting Server vs Client Components is ambiguous
 - Injecting hooks in Server Components causes runtime errors
 - User has full control over translation function placement
@@ -297,12 +393,14 @@ behavior:
 ```
 
 **Benefits:**
+
 - **Consistent keys**: Keys are always in English, even if your source text is in Spanish, French, German, etc.
 - **Readable**: `welcomeBack` instead of `bienvenidoDeNuevo`
 - **Stable**: Keys are cached per source text for deterministic behavior across runs
 - **Minimal diffs**: Same source text always produces the same key
 
 **How it works:**
+
 1. First run: AI generates an English key for each source text
 2. Key is cached with the source text hash
 3. Subsequent runs: Cached key is reused (no AI call needed)
@@ -311,12 +409,14 @@ behavior:
 **Example:**
 
 Source text (Spanish):
+
 ```tsx
 <h1>Bienvenido de nuevo</h1>
 <button>Iniciar sesión</button>
 ```
 
 Generated keys (English):
+
 ```json
 {
   "welcomeBack": "Bienvenido de nuevo",
@@ -335,6 +435,86 @@ behavior:
 
 Note: Keys will be in the source language (e.g., `bienvenidoDeNuevo` for Spanish text).
 
+### AI Provider and Model Configuration
+
+i18nizer supports multiple AI providers for translations. You can configure the provider and model in `i18nizer.config.yml`:
+
+```yaml
+ai:
+  provider: openai        # openai | gemini | huggingface
+  model: gpt-4           # AI model name
+```
+
+**Supported Providers:**
+
+- **OpenAI** (default): Uses OpenAI API with models like `gpt-4`, `gpt-4o-mini`, etc.
+- **Google Gemini**: Uses Google's Gemini API with models like `gemini-2.5-flash`, `gemini-pro`
+- **Hugging Face**: Uses Hugging Face Inference API with models like `deepseek-ai/DeepSeek-V3.2`
+
+**Default Configuration:**
+
+```yaml
+ai:
+  provider: openai
+  model: gpt-4
+```
+
+**Example Configurations:**
+
+For Google Gemini:
+```yaml
+ai:
+  provider: gemini
+  model: gemini-2.5-flash
+```
+
+For Hugging Face:
+```yaml
+ai:
+  provider: huggingface
+  model: deepseek-ai/DeepSeek-V3.2
+```
+
+**Note:** You still need to set up API keys using:
+```bash
+i18nizer keys --setOpenAI <YOUR_OPENAI_API_KEY>
+i18nizer keys --setGemini <YOUR_GEMINI_API_KEY>
+i18nizer keys --setHF <YOUR_HUGGING_FACE_API_KEY>
+```
+
+The provider setting in config file will be used by default, but you can override it on a per-command basis using the `--provider` flag:
+```bash
+i18nizer translate <file> --provider gemini
+```
+
+### Paths Configuration
+
+Configure default paths for your source code and i18n files in `i18nizer.config.yml`:
+
+```yaml
+paths:
+  src: src               # Source directory
+  i18n: i18n             # i18n output directory
+```
+
+**Default Configuration:**
+
+```yaml
+paths:
+  src: src
+  i18n: i18n
+```
+
+**Custom Example:**
+
+```yaml
+paths:
+  src: source
+  i18n: locales
+```
+
+These paths serve as defaults and can help organize your project structure. The `messages.path` setting (which specifies where translation JSON files are stored) is separate from `paths.i18n`.
+
 ---
 
 ## ✨ Features
@@ -350,6 +530,8 @@ Note: Keys will be in the source language (e.g., `bienvenidoDeNuevo` for Spanish
 - **Configurable behavior** (allowed functions, props, member functions)
 - **Dry-run mode** to preview changes
 - **JSON output preview** with `--show-json`
+- **Pluralization documentation** - comprehensive guide for ICU message format
+- **Rich text formatting documentation** - patterns for JSX within translations
 - Project-wide or single-file translation
 - Works with **JSX & TSX**
 - Rewrites components automatically (`t("key")`)
@@ -380,15 +562,138 @@ Note: Keys will be in the source language (e.g., `bienvenidoDeNuevo` for Spanish
 
 ---
 
+## 🎨 Advanced i18n Patterns
+
+i18nizer extracts translatable strings and generates standard i18n JSON files. For advanced patterns like pluralization and rich text formatting, you can leverage the built-in features of i18next and next-intl.
+
+### Pluralization Support
+
+Both i18next and next-intl support ICU message format for handling plurals. After i18nizer extracts your strings, you can enhance them with plural rules.
+
+**Before i18nizer:**
+```tsx
+<p>{count} {count === 1 ? 'item' : 'items'} in cart</p>
+```
+
+**After i18nizer extraction:**
+```tsx
+<p>{t('itemCount', { count })} {t('itemsLabel', { count })}</p>
+```
+
+**Manual enhancement to use pluralization:**
+```tsx
+<p>{t('itemsInCart', { count })}</p>
+```
+
+**Translation with ICU plural format:**
+```json
+{
+  "itemsInCart": "{count, plural, =0 {No items} one {# item} other {# items}} in cart"
+}
+```
+
+**How plurals work:**
+- `=0` - Exact match for zero
+- `one` - Singular form (1 item in English)
+- `other` - Plural form (2+ items)
+- `#` - Placeholder for the count number
+
+**Additional plural categories** (language-dependent):
+- `zero`, `one`, `two`, `few`, `many`, `other`
+
+### Rich Text Formatting
+
+When you need JSX elements within translated text (like links or bold text), both i18next and next-intl provide rich text formatting capabilities.
+
+**Before i18nizer:**
+```tsx
+<p>By clicking Sign Up, you agree to our <a href="/terms">Terms of Service</a></p>
+```
+
+**After i18nizer extraction:**
+```tsx
+<p>{t('byClickingSignUpYouAgree')} <a href="/terms">{t('termsOfService')}</a></p>
+```
+
+**Manual enhancement with rich text (next-intl):**
+```tsx
+<p>{t.rich('signUpAgreement', {
+  terms: (chunks) => <a href="/terms">{chunks}</a>
+})}</p>
+```
+
+**Translation:**
+```json
+{
+  "signUpAgreement": "By clicking Sign Up, you agree to our <terms>Terms of Service</terms>"
+}
+```
+
+**Using rich text with i18next:**
+```tsx
+import { Trans } from 'react-i18next';
+
+<p>
+  <Trans i18nKey="signUpAgreement">
+    By clicking Sign Up, you agree to our <a href="/terms">Terms of Service</a>
+  </Trans>
+</p>
+```
+
+**Translation:**
+```json
+{
+  "signUpAgreement": "By clicking Sign Up, you agree to our <1>Terms of Service</1>"
+}
+```
+
+### More Examples
+
+**Date and time formatting:**
+```tsx
+// Using next-intl
+<p>{t('lastUpdated', { date: new Date() })}</p>
+
+// Translation
+{
+  "lastUpdated": "Last updated: {date, date, medium}"
+}
+```
+
+**Number formatting:**
+```tsx
+// Using next-intl
+<p>{t('price', { amount: 99.99 })}</p>
+
+// Translation
+{
+  "price": "{amount, number, currency}"
+}
+```
+
+**Nested plurals:**
+```tsx
+<p>{t('cartSummary', { itemCount: 5, totalPrice: 149.99 })}</p>
+
+// Translation
+{
+  "cartSummary": "{itemCount, plural, one {# item} other {# items}} • Total: ${totalPrice}"
+}
+```
+
+---
+
 ## 🔮 Roadmap
 
 ### ✅ Phase 0: Foundation & Reliability (Complete)
+
 - Stable extraction and replacement
 - Deterministic key generation
 - Comprehensive test coverage
 - JSON output quality
 
 ### ✅ Phase 1: Project Integration (Complete)
+
 - `i18nizer start` command for project initialization
 - `i18nizer translate` command with `--all` flag
 - Configuration system with YAML
@@ -399,11 +704,13 @@ Note: Keys will be in the source language (e.g., `bienvenidoDeNuevo` for Spanish
 - Dry-run and JSON preview modes
 
 ### 🚧 Phase 2: Advanced Features (Planned)
+
+- [ ] Automatic pluralization detection and conversion
+- [ ] Automatic rich text formatting detection
 - [ ] Watch mode for continuous translation
 - [ ] Non-AI fallback mode
 - [ ] Framework support (Vue, Svelte)
 - [ ] Additional i18n library presets
-- [ ] Pluralization support
 - [ ] Context-aware translations
 - [ ] Translation memory and glossary
 
@@ -412,6 +719,7 @@ Note: Keys will be in the source language (e.g., `bienvenidoDeNuevo` for Spanish
 ## ⚠️ Current Limitations
 
 - AI-generated keys may vary between runs (deterministic fallback available)
+- Cached keys minimize diffs across runs.
 - Only supports React JSX/TSX (no Vue, Svelte yet)
 - Does not handle runtime-only string generation
 

package/dist/commands/extract.js

@@ -97,9 +97,14 @@ export default class Extract extends Command {
             const result = deduplicationResults.get(t.text);
             return {
                 isCached: result.isCached,
+                isPlural: t.isPlural,
+                isRichText: t.isRichText,
                 key: result.key,
                 node: t.node,
                 placeholders: t.placeholders,
+                pluralForms: t.pluralForms,
+                pluralVariable: t.pluralVariable,
+                richTextElements: t.richTextElements,
                 tempKey: t.tempKey,
                 text: t.text,
             };
@@ -122,13 +127,22 @@ export default class Extract extends Command {
             const i18nJson = {};
             // Use our generated keys, not the AI's keys
             for (const mapped of mappedTexts) {
-                const translations = jsonNamespace[mapped.tempKey];
-                if (!translations) {
-                    throw new Error(`No translations found for tempKey: ${mapped.tempKey}`);
-                }
                 i18nJson[mapped.key] = {};
-                for (const locale of locales) {
-                    i18nJson[mapped.key][locale] = translations[locale];
+                // For plural forms, generate ICU format directly
+                if (mapped.isPlural && mapped.pluralForms) {
+                    for (const locale of locales) {
+                        const icuFormat = `{${mapped.pluralVariable}, plural, one {${mapped.pluralForms.one}} other {${mapped.pluralForms.other}}}`;
+                        i18nJson[mapped.key][locale] = icuFormat;
+                    }
+                }
+                else {
+                    const translations = jsonNamespace[mapped.tempKey];
+                    if (!translations) {
+                        throw new Error(`No translations found for tempKey: ${mapped.tempKey}`);
+                    }
+                    for (const locale of locales) {
+                        i18nJson[mapped.key][locale] = translations[locale];
+                    }
                 }
                 // Update cache
                 cache.set({
@@ -143,9 +157,12 @@ export default class Extract extends Command {
             this.log(`🔗 Mapped ${chalk.green(mappedTexts.length)} texts to keys`);
             insertUseTranslations(sourceFile, componentName);
             replaceTempKeysWithT(mappedTexts.map((m) => ({
+                isPlural: m.isPlural,
+                isRichText: m.isRichText,
                 key: m.key,
                 node: m.node,
                 placeholders: m.placeholders,
+                richTextElements: m.richTextElements,
                 tempKey: m.tempKey,
             })));
             saveSourceFile(sourceFile);

package/dist/commands/translate.js

@@ -78,7 +78,8 @@ export default class Translate extends Command {
         const locales = flags.locales
             ? flags.locales.split(",")
             : config.messages.locales || [config.messages.defaultLocale, "es"]; // Use config locales or default fallback
-        let provider = "huggingface";
+        // Use provider from config or flag (flag takes precedence)
+        let provider = config.ai?.provider || "huggingface";
         if (flags.provider) {
             const p = flags.provider.toLowerCase();
             if (!VALID_PROVIDERS.includes(p)) {
@@ -86,6 +87,8 @@ export default class Translate extends Command {
             }
             provider = p;
         }
+        // Use model from config (can be undefined if not specified)
+        const aiModel = config.ai?.model;
         // Get files to process
         const filesToProcess = flags.all
             ? findProjectComponents(cwd)
@@ -137,9 +140,14 @@ export default class Translate extends Command {
                         totalCached++;
                     return {
                         isCached: result.isCached,
+                        isPlural: t.isPlural,
+                        isRichText: t.isRichText,
                         key: result.key,
                         node: t.node,
                         placeholders: t.placeholders,
+                        pluralForms: t.pluralForms,
+                        pluralVariable: t.pluralVariable,
+                        richTextElements: t.richTextElements,
                         tempKey: t.tempKey,
                         text: t.text,
                     };
@@ -157,9 +165,19 @@ export default class Translate extends Command {
                         }
                     }
                     else {
-                        // Will need AI translation
-                        for (const locale of locales) {
-                            i18nJson[mapped.key][locale] = ""; // Placeholder
+                        // For plural forms, generate ICU format
+                        if (mapped.isPlural && mapped.pluralForms) {
+                            for (const locale of locales) {
+                                // Generate ICU plural format string
+                                const icuFormat = `{${mapped.pluralVariable}, plural, one {${mapped.pluralForms.one}} other {${mapped.pluralForms.other}}}`;
+                                i18nJson[mapped.key][locale] = icuFormat;
+                            }
+                        }
+                        else {
+                            // Will need AI translation
+                            for (const locale of locales) {
+                                i18nJson[mapped.key][locale] = ""; // Placeholder
+                            }
                         }
                     }
                 }
@@ -176,7 +194,7 @@ export default class Translate extends Command {
                         })),
                     });
                     // eslint-disable-next-line no-await-in-loop
-                    const raw = await generateTranslations(prompt, provider);
+                    const raw = await generateTranslations(prompt, provider, aiModel);
                     if (!raw)
                         throw new Error("AI did not return any data");
                     const aiJson = parseAiJson(raw);
@@ -221,9 +239,12 @@ export default class Translate extends Command {
                         insertUseTranslations(sourceFile, componentName);
                     }
                     replaceTempKeysWithT(mappedTexts.map((m) => ({
+                        isPlural: m.isPlural,
+                        isRichText: m.isRichText,
                         key: m.key,
                         node: m.node,
                         placeholders: m.placeholders,
+                        richTextElements: m.richTextElements,
                         tempKey: m.tempKey,
                     })), {
                         allowedFunctions: config.behavior.allowedFunctions,

package/dist/core/ai/client.js

@@ -19,18 +19,19 @@ function loadApiKeys() {
         return {};
     }
 }
-export async function generateTranslations(prompt, provider = "huggingface") {
+export async function generateTranslations(prompt, provider = "huggingface", model) {
     const keys = loadApiKeys();
     switch (provider) {
         case "gemini": {
             const apiKey = keys.gemini;
             if (!apiKey)
                 throw new Error("Gemini API key is not set.");
-            console.log("🤖 Using Google Gemini...");
+            const geminiModel = model || "gemini-2.5-flash";
+            console.log(`🤖 Using Google Gemini (${geminiModel})...`);
             const gemini = new GoogleGenAI({ apiKey });
             const result = await gemini.models.generateContent({
                 contents: prompt,
-                model: "gemini-2.5-flash",
+                model: geminiModel,
             });
             return result.text;
         }
@@ -38,12 +39,13 @@ export async function generateTranslations(prompt, provider = "huggingface") {
             const apiKey = keys.huggingface;
             if (!apiKey)
                 throw new Error("Hugging Face API key is not set.");
-            console.log("🤖 Using Hugging Face (DeepSeek-V3.2)...");
+            const hfModel = model || "deepseek-ai/DeepSeek-V3.2";
+            console.log(`🤖 Using Hugging Face (${hfModel})...`);
             const hfClient = new HFClient(apiKey);
             try {
                 const chatCompletion = await hfClient.chatCompletion({
                     messages: [{ content: prompt, role: "user" }],
-                    model: "deepseek-ai/DeepSeek-V3.2",
+                    model: hfModel,
                 });
                 return chatCompletion.choices?.[0]?.message?.content || (typeof chatCompletion.output_text === "string" ? chatCompletion.output_text : undefined);
             }
@@ -56,12 +58,13 @@ export async function generateTranslations(prompt, provider = "huggingface") {
             const apiKey = keys.openai;
             if (!apiKey)
                 throw new Error("OpenAI API key is not set.");
-            console.log("🤖 Using OpenAI...");
+            const openaiModel = model || "gpt-4o-mini";
+            console.log(`🤖 Using OpenAI (${openaiModel})...`);
             const openai = new OpenAI({ apiKey });
             try {
                 const completion = await openai.chat.completions.create({
                     messages: [{ content: prompt, role: "user" }],
-                    model: "gpt-4o-mini",
+                    model: openaiModel,
                 });
                 return completion.choices?.[0]?.message?.content || "";
             }

package/dist/core/ast/extract-text.js

@@ -34,6 +34,138 @@ function processTemplateLiteral(node) {
     }
     return null;
 }
+/**
+ * Extract rich text content from JSX element with child elements
+ * Converts: <p>Click <a>here</a> to continue</p>
+ * To: "Click <a>here</a> to continue"
+ */
+function extractRichTextContent(jsxElement) {
+    if (!Node.isJsxElement(jsxElement)) {
+        return null;
+    }
+    const pattern = detectRichTextPattern(jsxElement);
+    if (!pattern) {
+        return null;
+    }
+    const children = jsxElement.getJsxChildren();
+    let richText = '';
+    const elements = [];
+    const seenPlaceholders = new Set();
+    for (const child of children) {
+        if (Node.isJsxText(child)) {
+            richText += child.getText();
+        }
+        else if (Node.isJsxElement(child)) {
+            const opening = child.getOpeningElement();
+            const tagName = opening.getTagNameNode().getText();
+            const placeholder = tagName.toLowerCase();
+            // Get inner text of the element
+            const innerText = child.getJsxChildren()
+                .filter(c => Node.isJsxText(c))
+                .map(c => c.getText())
+                .join('');
+            // Add to rich text with placeholder
+            richText += `<${placeholder}>${innerText}</${placeholder}>`;
+            // Track unique elements
+            if (!seenPlaceholders.has(placeholder)) {
+                elements.push({ tag: tagName, placeholder });
+                seenPlaceholders.add(placeholder);
+            }
+        }
+    }
+    return {
+        elements,
+        text: richText.trim(),
+    };
+}
+/**
+ * Detect rich text pattern - JSX element containing both text and child JSX elements
+ * Example: <p>Click <a>here</a> to continue</p>
+ */
+function detectRichTextPattern(jsxElement) {
+    if (!Node.isJsxElement(jsxElement) && !Node.isJsxSelfClosingElement(jsxElement)) {
+        return null;
+    }
+    if (Node.isJsxSelfClosingElement(jsxElement)) {
+        return null; // Self-closing elements don't have rich text
+    }
+    const children = jsxElement.getJsxChildren();
+    let hasText = false;
+    let hasJsxElement = false;
+    const elements = [];
+    for (const child of children) {
+        if (Node.isJsxText(child)) {
+            const text = child.getText().trim();
+            if (text.length > 0) {
+                hasText = true;
+            }
+        }
+        else if (Node.isJsxElement(child) || Node.isJsxSelfClosingElement(child)) {
+            hasJsxElement = true;
+            // Get tag name
+            const opening = Node.isJsxElement(child)
+                ? child.getOpeningElement()
+                : child;
+            const tagName = opening.getTagNameNode().getText();
+            // Generate placeholder name based on tag
+            const placeholder = tagName.toLowerCase();
+            elements.push({ tag: tagName, placeholder });
+        }
+    }
+    // Rich text pattern: has both text and JSX elements
+    if (hasText && hasJsxElement) {
+        return { elements, hasText: true };
+    }
+    return null;
+}
+/**
+ * Detect pluralization pattern in a ternary expression
+ * Pattern: variable === 1 ? 'singular' : 'plural'
+ */
+function detectPluralizationPattern(expr) {
+    if (!Node.isConditionalExpression(expr))
+        return null;
+    const condition = expr.getCondition();
+    const whenTrue = expr.getWhenTrue();
+    const whenFalse = expr.getWhenFalse();
+    // Check if condition is a binary expression (e.g., count === 1 or count == 1)
+    if (!Node.isBinaryExpression(condition))
+        return null;
+    const operator = condition.getOperatorToken().getText();
+    if (operator !== "===" && operator !== "==")
+        return null;
+    const left = condition.getLeft();
+    const right = condition.getRight();
+    // Check if one side is 1 and the other is a variable
+    let variable = null;
+    let isCheckingForOne = false;
+    if (Node.isNumericLiteral(right) && right.getLiteralValue() === 1 && Node.isIdentifier(left)) {
+        variable = left.getText();
+        isCheckingForOne = true;
+    }
+    else if (Node.isNumericLiteral(left) && left.getLiteralValue() === 1 && Node.isIdentifier(right)) {
+        variable = right.getText();
+        isCheckingForOne = true;
+    }
+    if (!variable || !isCheckingForOne)
+        return null;
+    // Extract singular and plural forms
+    let singular = null;
+    let plural = null;
+    if (Node.isStringLiteral(whenTrue)) {
+        singular = whenTrue.getLiteralText();
+    }
+    if (Node.isStringLiteral(whenFalse)) {
+        plural = whenFalse.getLiteralText();
+    }
+    if (!singular || !plural)
+        return null;
+    return {
+        pluralVariable: variable,
+        one: singular,
+        other: plural,
+    };
+}
 function getFullCallName(node) {
     if (Node.isIdentifier(node))
         return node.getText();
@@ -73,6 +205,31 @@ function extractStringsFromExpression(expr, results, seenNodes) {
     }
     // Ternary operator: condition ? whenTrue : whenFalse
     if (Node.isConditionalExpression(expr)) {
+        // Check if this is a pluralization pattern
+        const pluralPattern = detectPluralizationPattern(expr);
+        if (pluralPattern) {
+            // This is a pluralization pattern, create a single entry for it
+            const tempKey = `i$fdw_${tempIdCounter++}`;
+            const text = pluralPattern.other; // Use plural form as base text
+            results.push({
+                node: expr,
+                placeholders: [pluralPattern.pluralVariable],
+                tempKey,
+                text,
+                isPlural: true,
+                pluralVariable: pluralPattern.pluralVariable,
+                pluralForms: {
+                    one: pluralPattern.one,
+                    other: pluralPattern.other,
+                },
+            });
+            seenNodes.add(expr);
+            // Mark child nodes as seen to avoid duplicate extraction
+            seenNodes.add(expr.getWhenTrue());
+            seenNodes.add(expr.getWhenFalse());
+            return;
+        }
+        // Not a pluralization pattern, extract strings normally
         extractStringsFromExpression(expr.getWhenTrue(), results, seenNodes);
         extractStringsFromExpression(expr.getWhenFalse(), results, seenNodes);
         return;
@@ -102,6 +259,25 @@ export function extractTexts(sourceFile, options = {}) {
     sourceFile.forEachDescendant((node) => {
         if (seenNodes.has(node))
             return;
+        // Check for rich text pattern in JSX elements
+        if (Node.isJsxElement(node)) {
+            const richContent = extractRichTextContent(node);
+            if (richContent) {
+                const tempKey = `i$fdw_${tempIdCounter++}`;
+                results.push({
+                    isRichText: true,
+                    node,
+                    placeholders: richContent.elements.map(e => e.placeholder),
+                    richTextElements: richContent.elements,
+                    tempKey,
+                    text: richContent.text,
+                });
+                seenNodes.add(node);
+                // Mark all children as seen to avoid duplicate extraction
+                node.getJsxChildren().forEach(child => seenNodes.add(child));
+                return;
+            }
+        }
         let text = null;
         let placeholders = [];
         // JSXText

package/dist/core/ast/replace-text-with-text.js

@@ -33,12 +33,35 @@ export function replaceTempKeysWithT(mapped, options = {}) {
     const allowedProps = new Set(options.allowedProps ?? [...defaultAllowedProps]);
     const allowedFunctions = new Set(options.allowedFunctions ?? [...defaultAllowedFunctions]);
     const allowedMemberFunctions = new Set(options.allowedMemberFunctions ?? [...defaultAllowedMemberFunctions]);
-    for (const { key, node, placeholders = [] } of mapped) {
+    for (const { key, node, placeholders = [], isPlural = false, isRichText = false, richTextElements = [] } of mapped) {
+        // For rich text patterns, generate t.rich() call
+        if (isRichText && Node.isJsxElement(node)) {
+            // Build formatter functions for each element
+            const formatters = richTextElements.map(elem => {
+                return `${elem.placeholder}: (chunks) => <${elem.tag}>{chunks}</${elem.tag}>`;
+            }).join(', ');
+            const richCall = `t.rich("${key}", { ${formatters} })`;
+            // Replace the entire JSX element with {t.rich(...)}
+            node.replaceWithText(`{${richCall}}`);
+            continue;
+        }
         // Build placeholders string if any
         const placeholdersText = placeholders.length > 0
             ? `{ ${placeholders.map(p => `${p}: ${p}`).join(", ")} }`
             : "";
         const tCall = `t("${key}"${placeholdersText ? `, ${placeholdersText}` : ""})`;
+        // For plural patterns (ternary expressions), replace the entire ternary
+        if (isPlural && Node.isConditionalExpression(node)) {
+            const parent = node.getParent();
+            // In JSX expression
+            if (Node.isJsxExpression(parent)) {
+                node.replaceWithText(tCall);
+                return;
+            }
+            // In other contexts, replace with t() call
+            node.replaceWithText(tCall);
+            continue;
+        }
         // Replace JSXText nodes → {t("key")}
         if (Node.isJsxText(node)) {
             node.replaceWithText(`{${tCall}}`);

package/dist/core/config/config-manager.js

@@ -1,9 +1,10 @@
+import yaml from "js-yaml";
 import fs from "node:fs";
 import path from "node:path";
-import yaml from "js-yaml";
 import { DEFAULT_CONFIG, FRAMEWORK_PRESETS, I18N_LIBRARY_CONFIGS } from "../../types/config.js";
 const CONFIG_FILE_NAME = "i18nizer.config.yml";
 const PROJECT_DIR_NAME = ".i18nizer";
+const VALID_AI_PROVIDERS = ["openai", "gemini", "huggingface"];
 /**
  * Detect project type by looking for framework-specific files
  */
@@ -13,10 +14,10 @@ export function detectFramework(cwd) {
         try {
             const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
             const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-            if (deps["next"]) {
+            if (deps.next) {
                 return "nextjs";
             }
-            if (deps["react"]) {
+            if (deps.react) {
                 return "react";
             }
         }
@@ -42,7 +43,7 @@ export function detectI18nLibrary(cwd) {
             if (deps["react-i18next"]) {
                 return "react-i18next";
             }
-            if (deps["i18next"]) {
+            if (deps.i18next) {
                 return "i18next";
             }
         }
@@ -52,6 +53,12 @@ export function detectI18nLibrary(cwd) {
     }
     return null; // No i18n library detected
 }
+/**
+ * Validate AI provider value
+ */
+export function validateAiProvider(provider) {
+    return VALID_AI_PROVIDERS.includes(provider);
+}
 /**
  * Load configuration from the project root
  */
@@ -63,6 +70,10 @@ export function loadConfig(cwd) {
     try {
         const fileContent = fs.readFileSync(configPath, "utf8");
         const parsed = yaml.load(fileContent, { schema: yaml.CORE_SCHEMA });
+        // Validate AI provider if specified
+        if (parsed.ai?.provider && !validateAiProvider(parsed.ai.provider)) {
+            throw new Error(`Invalid AI provider: ${parsed.ai.provider}. Valid options: ${VALID_AI_PROVIDERS.join(", ")}`);
+        }
         // Deep merge with defaults
         return mergeConfig(DEFAULT_CONFIG, parsed);
     }
@@ -75,24 +86,32 @@ export function loadConfig(cwd) {
  */
 function mergeConfig(base, override) {
     return {
+        ai: override.ai ? {
+            ...base.ai,
+            ...override.ai,
+        } : base.ai,
         behavior: {
             ...base.behavior,
             ...override.behavior,
         },
         framework: override.framework ?? base.framework,
-        i18nLibrary: override.i18nLibrary ?? base.i18nLibrary,
         i18n: {
             ...base.i18n,
             ...override.i18n,
             import: {
                 ...base.i18n.import,
-                ...(override.i18n?.import ?? {}),
+                ...override.i18n?.import,
             },
         },
+        i18nLibrary: override.i18nLibrary ?? base.i18nLibrary,
         messages: {
             ...base.messages,
             ...override.messages,
         },
+        paths: override.paths ? {
+            ...base.paths,
+            ...override.paths,
+        } : base.paths,
     };
 }
 /**
@@ -112,8 +131,8 @@ export function generateConfig(framework, i18nLibrary) {
         const i18nConfig = I18N_LIBRARY_CONFIGS[i18nLibrary];
         return {
             ...baseConfig,
-            i18nLibrary: i18nConfig.i18nLibrary,
             i18n: i18nConfig.i18n ?? baseConfig.i18n,
+            i18nLibrary: i18nConfig.i18nLibrary,
         };
     }
     return baseConfig;

package/dist/types/config.js

@@ -2,6 +2,10 @@
  * Configuration types for i18nizer
  */
 export const DEFAULT_CONFIG = {
+    ai: {
+        model: "gpt-4",
+        provider: "openai",
+    },
     behavior: {
         allowedFunctions: ["alert", "confirm", "prompt"],
         allowedMemberFunctions: ["toast.error", "toast.info", "toast.success", "toast.warn"],
@@ -35,12 +39,15 @@ export const DEFAULT_CONFIG = {
         locales: ["en", "es"],
         path: "messages",
     },
+    paths: {
+        i18n: "i18n",
+        src: "src",
+    },
 };
 export const FRAMEWORK_PRESETS = {
     custom: {},
     nextjs: {
         framework: "nextjs",
-        i18nLibrary: "next-intl",
         i18n: {
             function: "t",
             import: {
@@ -48,10 +55,10 @@ export const FRAMEWORK_PRESETS = {
                 source: "next-intl",
             },
         },
+        i18nLibrary: "next-intl",
     },
     react: {
         framework: "react",
-        i18nLibrary: "react-i18next",
         i18n: {
             function: "t",
             import: {
@@ -59,14 +66,14 @@ export const FRAMEWORK_PRESETS = {
                 source: "react-i18next",
             },
         },
+        i18nLibrary: "react-i18next",
     },
 };
 /**
  * I18n library-specific configurations
  */
 export const I18N_LIBRARY_CONFIGS = {
-    "next-intl": {
-        i18nLibrary: "next-intl",
+    custom: {
         i18n: {
             function: "t",
             import: {
@@ -74,35 +81,36 @@ export const I18N_LIBRARY_CONFIGS = {
                 source: "next-intl",
             },
         },
+        i18nLibrary: "custom",
     },
-    "react-i18next": {
-        i18nLibrary: "react-i18next",
+    "i18next": {
         i18n: {
             function: "t",
             import: {
                 named: "useTranslation",
-                source: "react-i18next",
+                source: "react-i18next", // Default to react-i18next for React apps
             },
         },
-    },
-    "i18next": {
         i18nLibrary: "i18next",
+    },
+    "next-intl": {
         i18n: {
             function: "t",
             import: {
-                named: "useTranslation",
-                source: "react-i18next", // Default to react-i18next for React apps
+                named: "useTranslations",
+                source: "next-intl",
             },
         },
+        i18nLibrary: "next-intl",
     },
-    custom: {
-        i18nLibrary: "custom",
+    "react-i18next": {
         i18n: {
             function: "t",
             import: {
-                named: "useTranslations",
-                source: "next-intl",
+                named: "useTranslation",
+                source: "react-i18next",
             },
         },
+        i18nLibrary: "react-i18next",
     },
 };

package/oclif.manifest.json

@@ -330,5 +330,5 @@
       ]
     }
   },
-  "version": "0.6.2"
+  "version": "0.7.1"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "i18nizer",
   "description": "CLI to extract texts from JSX/TSX and generate i18n JSON with AI translations",
-  "version": "0.6.2",
+  "version": "0.7.1",
   "author": "Yoannis Sanchez Soto",
   "bin": "./bin/run.js",
   "bugs": "https://github.com/yossTheDev/i18nizer/issues",