i18nizer 0.1.0

package/README.md

@@ -0,0 +1,144 @@
+# i18nizer 🌍
+
+![banner](./imgs/banner.png)
+
+<div align="center">
+<img src="https://img.shields.io/badge/Node.js-5FA04E?logo=nodedotjs&logoColor=fff&style=for-the-badge" alt="Node.js Badge">
+<img src="https://img.shields.io/badge/oclif-000?logo=oclif&logoColor=fff&style=for-the-badge" alt="oclif Badge">
+<img src="https://img.shields.io/badge/TypeScript-3178C6?logo=typescript&logoColor=fff&style=for-the-badge" alt="TypeScript Badge">
+<img alt="Licence" src="https://img.shields.io/npm/dw/i18nizer.svg?style=for-the-badge">
+<img alt="Licence" src="https://img.shields.io/github/license/yossTheDev/i18nizer?style=for-the-badge">
+</div>
+
+i18nizer is a practical CLI to **extract translatable texts from your TSX/JSX components** and automatically generate i18n JSON files.
+It works with **Gemini** and **Hugging Face (DeepSeek)** AI providers to generate translations and prepares your components to use `t()` easily.
+
+---
+
+## 🚀 Installation
+
+You can install the CLI globally using **npm**:
+
+```bash
+npm install -g i18nizer
+```
+
+> Requires Node.js 18+ and internet access to call the translation APIs.
+
+---
+
+## 🛠️ API Keys Configuration
+
+Before generating translations, you need to set up your API keys:
+
+```bash
+i18nizer keys --setGemini <YOUR_GEMINI_API_KEY>
+i18nizer keys --setHF <YOUR_HUGGING_FACE_API_KEY>
+```
+
+* Keys are stored securely in your **global user folder** (`~/.mycli/api-keys.json` on Linux/Mac or `C:\Users\<User>\.mycli\api-keys.json` on Windows).
+* To see which keys are set (partially masked):
+
+```bash
+i18nizer keys --show
+```
+
+---
+
+## ⚡ Main Commands
+
+### 1. Extract and Generate Translations
+
+```bash
+i18nizer extract <file-path>
+```
+
+**Available flags:**
+
+* `-l, --locales` → List of locales to generate (default: `en,es`)
+* `-p, --provider` → AI provider to generate translations (optional, default: `huggingface`). Options: `gemini`, `huggingface`
+
+**Example:**
+
+```bash
+i18nizer extract src/components/Button.tsx --locales en,es,fr --provider gemini
+```
+
+**What this command does:**
+
+* Extracts all translatable texts from your JSX/TSX file.
+* Generates translations using the selected AI provider.
+* Automatically inserts `t()` calls in the component.
+* Saves JSON files in `messages/<locale>/<component>.json`.
+* Logs the paths of generated files.
+
+---
+
+### 2. Manage API Keys
+
+```bash
+i18nizer keys
+```
+
+**Available flags:**
+
+* `--setGemini` → Set your Gemini key
+* `--setHF` → Set your Hugging Face key
+* `--show` → Show stored keys (masked)
+
+---
+
+## 💡 Current Features
+
+* Compatible with **JSX and TSX**
+* Works with AI providers: **Gemini**, **Hugging Face (DeepSeek)**
+* Automatically inserts `t()` calls in components
+* Generates JSON files for each locale
+* Spinner and colored logs with emojis for better UX
+
+---
+
+## 🔮 Future Ideas
+
+* Configurable **output directory** for JSON files
+* Support for other frameworks and file types (Vue, Svelte, etc.)
+* Better integration with `next-intl` or `react-i18next`
+* Keychain / Credential Manager support for storing API keys securely
+* Multi-project support and locale presets
+
+---
+
+## 📂 Output Structure
+
+```
+messages/
+├─ en/
+│  └─ Button.json
+├─ es/
+│  └─ Button.json
+└─ fr/
+   └─ Button.json
+```
+
+Each JSON contains a namespace with AI-generated keys:
+
+```json
+{
+  "button": {
+    "submitText": "Submit",
+    "cancelText": "Cancel"
+  }
+}
+```
+
+---
+
+## ⚠️ Notes
+
+* For the first version, JSON files are saved **inside the project** under `messages/<locale>/`.
+* Make sure **not to commit your API keys** to the repository.
+* The CLI is designed to be simple and functional, ideal for starting automatic i18n in React projects.
+
+---
+
+> Made with ❤️ by Yoannis Sánchez Soto

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env -S node --loader ts-node/esm --disable-warning=ExperimentalWarning
+
+import {execute} from '@oclif/core'
+
+await execute({development: true, dir: import.meta.url})

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import {execute} from '@oclif/core'
+
+await execute({dir: import.meta.url})

package/dist/commands/extract.js

@@ -0,0 +1,98 @@
+import { Args, Command, Flags } from "@oclif/core";
+import chalk from "chalk";
+import path from "node:path";
+import ora from "ora";
+import { generateTranslations } from "../core/ai/client.js";
+import { buildPrompt } from "../core/ai/promt.js";
+import { extractTexts } from "../core/ast/extract-text.js";
+import { insertUseTranslations } from "../core/ast/insert-user-translations.js";
+import { parseFile } from "../core/ast/parse-file.js";
+import { replaceTempKeysWithT } from "../core/ast/replace-text-with-text.js";
+import { parseAiJson } from "../core/i18n/parse-ai-json.js";
+import { saveSourceFile } from "../core/i18n/sace-source-file.js";
+import { writeLocaleFiles } from "../core/i18n/write-files.js";
+const VALID_PROVIDERS = ["gemini", "huggingface", "openai"];
+export default class Extract extends Command {
+    static args = {
+        file: Args.string({
+            description: "Path to the TSX/JSX file",
+            required: true,
+        }),
+    };
+    static description = "🌍 Extract translatable strings from a TSX/JSX file and generate i18n JSON";
+    static flags = {
+        locales: Flags.string({
+            char: "l",
+            default: "en,es",
+            description: "Locales to generate",
+        }),
+        provider: Flags.string({
+            char: "p",
+            description: "AI provider (gemini | huggingface), optional",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Extract);
+        this.log(chalk.cyan("📄 File:"), args.file);
+        this.log(chalk.cyan("🌐 Locales:"), flags.locales);
+        let provider = "huggingface";
+        if (flags.provider) {
+            const p = flags.provider.toLowerCase();
+            if (!VALID_PROVIDERS.includes(p)) {
+                this.error(`❌ Invalid provider: ${flags.provider}. Valid options: ${VALID_PROVIDERS.join(", ")}`);
+            }
+            provider = p;
+        }
+        this.log(chalk.cyan("🤖 Provider:"), provider);
+        // Parse file
+        const sourceFile = parseFile(args.file);
+        const texts = extractTexts(sourceFile);
+        if (texts.length === 0) {
+            this.log(chalk.yellow("⚠️  No translatable texts found."));
+            return;
+        }
+        this.log(`🔍 Found ${chalk.green(texts.length)} translatable texts`);
+        const componentName = path
+            .basename(args.file)
+            .replace(/\.(tsx|jsx)$/, "");
+        const locales = flags.locales.split(",");
+        const spinner = ora(`💬 Generating translations with ${provider}...`).start();
+        try {
+            const prompt = buildPrompt({
+                componentName,
+                locales,
+                texts: texts.map((t) => t.text),
+            });
+            // Pasamos el provider a la función
+            const raw = await generateTranslations(prompt, provider);
+            if (!raw)
+                throw new Error("AI did not return any data");
+            const json = parseAiJson(raw);
+            writeLocaleFiles(componentName, json, locales);
+            spinner.succeed(`✅ Translations generated with ${provider}`);
+            const namespace = componentName.toLowerCase();
+            const aiGeneratedKeys = Object.keys(json[namespace] || {});
+            const mapped = texts.map((e, i) => ({
+                key: aiGeneratedKeys[i],
+                node: e.node,
+                placeholders: e.placeholders,
+                tempKey: e.tempKey,
+            }));
+            this.log(`🔗 Mapped ${chalk.green(mapped.length)} texts to keys`);
+            insertUseTranslations(sourceFile, componentName);
+            replaceTempKeysWithT(mapped);
+            saveSourceFile(sourceFile);
+            this.log(chalk.green("✨ Component rewritten with t() calls"));
+            this.log(chalk.green(`🌍 JSON files generated using ${provider}`));
+        }
+        catch (error) {
+            spinner.fail(`❌ Failed to generate translations with ${provider}`);
+            if (error instanceof Error) {
+                this.error(error.message);
+            }
+            else {
+                this.error("An unknown error occurred");
+            }
+        }
+    }
+}

package/dist/commands/hello/index.js

@@ -0,0 +1,19 @@
+import { Args, Command, Flags } from '@oclif/core';
+export default class Hello extends Command {
+    static args = {
+        person: Args.string({ description: 'Person to say hello to', required: true }),
+    };
+    static description = 'Say hello';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> friend --from oclif
+hello friend from oclif! (./src/commands/hello/index.ts)
+`,
+    ];
+    static flags = {
+        from: Flags.string({ char: 'f', description: 'Who is saying hello', required: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Hello);
+        this.log(`hello ${args.person} from ${flags.from}! (./src/commands/hello/index.ts)`);
+    }
+}

package/dist/commands/hello/world.js

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class World extends Command {
+    static args = {};
+    static description = 'Say hello world';
+    static examples = [
+        `<%= config.bin %> <%= command.id %>
+hello world! (./src/commands/hello/world.ts)
+`,
+    ];
+    static flags = {};
+    async run() {
+        this.log('hello world! (./src/commands/hello/world.ts)');
+    }
+}

package/dist/commands/keys.js

@@ -0,0 +1,74 @@
+import { Command, Flags } from "@oclif/core";
+import chalk from "chalk";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import ora from "ora";
+const CONFIG_DIR = path.join(os.homedir(), ".18nizer");
+const CONFIG_FILE = path.join(CONFIG_DIR, "api-keys.json");
+export default class Keys extends Command {
+    static description = "Manage API keys for your CLI";
+    static flags = {
+        setGemini: Flags.string({
+            char: "g",
+            description: "Set Google Gemini API key",
+        }),
+        setHF: Flags.string({
+            char: "h",
+            description: "Set Hugging Face API key",
+        }),
+        setOpenAI: Flags.string({
+            char: "o",
+            description: "Set OpenAI API key",
+        }),
+        show: Flags.boolean({
+            char: "s",
+            description: "Show saved keys (masked)",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Keys);
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        let keys = {};
+        if (fs.existsSync(CONFIG_FILE)) {
+            try {
+                keys = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+            }
+            catch {
+                this.error("❌ Could not read existing keys file.");
+            }
+        }
+        // Set keys
+        if (flags.setGemini) {
+            keys.gemini = flags.setGemini;
+            this.log(chalk.green("✅ Gemini API key set"));
+        }
+        if (flags.setHF) {
+            keys.huggingface = flags.setHF;
+            this.log(chalk.green("✅ Hugging Face API key set"));
+        }
+        if (flags.setOpenAI) {
+            keys.openai = flags.setOpenAI;
+            this.log(chalk.green("✅ OpenAI API key set"));
+        }
+        // Save keys
+        if (flags.setGemini || flags.setHF || flags.setOpenAI) {
+            const spinner = ora("Saving keys...").start();
+            try {
+                fs.writeFileSync(CONFIG_FILE, JSON.stringify(keys, null, 2), { mode: 0o600 });
+                spinner.succeed(`💾 Keys saved successfully at ${CONFIG_FILE}`);
+            }
+            catch {
+                spinner.fail("❌ Failed to save keys");
+            }
+        }
+        // Show keys (masked)
+        if (flags.show) {
+            this.log("🔑 Saved API keys:");
+            this.log("Gemini: ", keys.gemini ? keys.gemini.slice(0, 4) + "****" : chalk.yellow("not set"));
+            this.log("Hugging Face: ", keys.huggingface ? keys.huggingface.slice(0, 4) + "****" : chalk.yellow("not set"));
+        }
+    }
+}

package/dist/core/ai/client.js

@@ -0,0 +1,77 @@
+import { GoogleGenAI } from "@google/genai";
+import { InferenceClient as HFClient } from "@huggingface/inference";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import OpenAI from "openai";
+const CONFIG_FILE = path.join(os.homedir(), ".18nizer", "api-keys.json");
+function loadApiKeys() {
+    if (!fs.existsSync(CONFIG_FILE)) {
+        console.warn(`⚠️ API keys file not found: ${CONFIG_FILE}`);
+        return {};
+    }
+    try {
+        const keys = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+        return keys;
+    }
+    catch (error) {
+        console.error("❌ Error reading API keys:", error);
+        return {};
+    }
+}
+export async function generateTranslations(prompt, provider = "huggingface") {
+    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 gemini = new GoogleGenAI({ apiKey });
+            const result = await gemini.models.generateContent({
+                contents: prompt,
+                model: "gemini-2.5-flash",
+            });
+            return result.text;
+        }
+        case "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 hfClient = new HFClient(apiKey);
+            try {
+                const chatCompletion = await hfClient.chatCompletion({
+                    messages: [{ content: prompt, role: "user" }],
+                    model: "deepseek-ai/DeepSeek-V3.2",
+                });
+                return chatCompletion.choices?.[0]?.message?.content || (typeof chatCompletion.output_text === "string" ? chatCompletion.output_text : undefined);
+            }
+            catch (error) {
+                console.error("❌ Error calling Hugging Face:", error);
+                return undefined;
+            }
+        }
+        case "openai": {
+            const apiKey = keys.openai;
+            if (!apiKey)
+                throw new Error("OpenAI API key is not set.");
+            console.log("🤖 Using OpenAI...");
+            const openai = new OpenAI({ apiKey });
+            try {
+                const completion = await openai.chat.completions.create({
+                    messages: [{ content: prompt, role: "user" }],
+                    model: "gpt-4o-mini",
+                });
+                return completion.choices?.[0]?.message?.content || "";
+            }
+            catch (error) {
+                console.error("❌ Error calling OpenAI:", error);
+                return "";
+            }
+        }
+        default: {
+            throw new Error("Provider not supported");
+        }
+    }
+}

package/dist/core/ai/promt.js

@@ -0,0 +1,30 @@
+export function buildPrompt({ componentName, locales, texts, }) {
+    return `
+You are an i18n automation tool.
+
+TASK:
+Generate translation keys and translations for a React component.
+
+RULES:
+- Keys must be camelCase
+- Namespace must be "${componentName}"
+- Languages: ${locales.join(", ")}
+- Do NOT invent or modify meaning
+- Do NOT add explanations
+- Do NOT add markdown
+- Output ONLY valid JSON
+
+FORMAT EXACTLY:
+{
+  "${componentName}": {
+    "keyName": {
+      "${locales[0]}": "...",
+      "${locales[1]}": "..."
+    }
+  }
+}
+
+TEXTS:
+${texts.map((t) => `"${t}"`).join("\n")}
+`.trim();
+}

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

@@ -0,0 +1,78 @@
+import { Node } from "ts-morph";
+let tempIdCounter = 0;
+const allowedFunctions = new Set(["alert", "confirm", "prompt"]);
+function processTemplateLiteral(node) {
+    if (Node.isNoSubstitutionTemplateLiteral(node)) {
+        return { placeholders: [], text: node.getLiteralText() };
+    }
+    if (Node.isTemplateExpression(node)) {
+        let text = node.getHead().getLiteralText();
+        const placeholders = [];
+        for (const span of node.getTemplateSpans()) {
+            const exprText = span.getExpression().getText();
+            const literalText = span.getLiteral().getLiteralText();
+            text += `{${exprText}}${literalText}`;
+            placeholders.push(exprText);
+        }
+        return { placeholders, text };
+    }
+    return null;
+}
+export function extractTexts(sourceFile) {
+    const results = [];
+    sourceFile.forEachDescendant((node) => {
+        // JSX TEXT simple
+        if (Node.isJsxText(node)) {
+            const text = node.getText().trim();
+            if (text) {
+                const tempKey = `i$fdw_${tempIdCounter++}`;
+                results.push({ node, placeholders: [], tempKey, text });
+            }
+        }
+        // JSX Expression con TemplateLiteral
+        if (Node.isJsxExpression(node)) {
+            const expr = node.getExpression();
+            if (expr && (Node.isTemplateExpression(expr) || Node.isNoSubstitutionTemplateLiteral(expr))) {
+                const processed = processTemplateLiteral(expr);
+                if (processed) {
+                    const tempKey = `i$fdw_${tempIdCounter++}`;
+                    results.push({ node: expr, placeholders: processed.placeholders, tempKey, text: processed.text });
+                }
+            }
+        }
+        // STRING LITERALS
+        if (Node.isStringLiteral(node)) {
+            const text = node.getLiteralText();
+            const parent = node.getParent();
+            // JSX Attributes permitidos
+            const allowedProps = ["placeholder", "title", "alt", "aria-label"];
+            if (Node.isJsxAttribute(parent) && allowedProps.includes(parent.getNameNode().getText())) {
+                const tempKey = `i$fdw_${tempIdCounter++}`;
+                results.push({ node, placeholders: [], tempKey, text });
+            }
+            // Funciones tipo alert, confirm, prompt
+            if (Node.isCallExpression(parent)) {
+                const fnName = parent.getExpression().getText();
+                if (allowedFunctions.has(fnName)) {
+                    const tempKey = `i$fdw_${tempIdCounter++}`;
+                    results.push({ node, placeholders: [], tempKey, text });
+                }
+            }
+        }
+        // TEMPLATE LITERALS para alert/confirm/prompt
+        if (Node.isTemplateExpression(node) || Node.isNoSubstitutionTemplateLiteral(node)) {
+            const parent = node.getParent();
+            if (Node.isCallExpression(parent)) {
+                const fnName = parent.getExpression().getText();
+                if (allowedFunctions.has(fnName)) {
+                    const processed = processTemplateLiteral(node);
+                    if (processed) {
+                        const tempKey = `i$fdw_${tempIdCounter++}`;
+                        results.push({ node, placeholders: processed.placeholders, tempKey, text: processed.text });
+                    }
+                }
+            }
+        }
+    });
+    return results;
+}

package/dist/core/ast/insert-user-translations.js

@@ -0,0 +1,42 @@
+import { SyntaxKind, VariableDeclarationKind } from "ts-morph";
+export function insertUseTranslations(sourceFile, namespace) {
+    const defaultExport = sourceFile.getDefaultExportSymbol();
+    if (!defaultExport)
+        return;
+    const declarations = defaultExport.getDeclarations();
+    if (declarations.length === 0)
+        return;
+    const decl = declarations[0];
+    // Function Component tradicional
+    if (decl.getKind() === SyntaxKind.FunctionDeclaration) {
+        const body = decl.asKind(SyntaxKind.FunctionDeclaration)?.getBody();
+        if (!body)
+            return;
+        if (!body.getVariableStatements().some(vs => vs.getDeclarations().some(d => d.getName() === "t"))) {
+            body.insertVariableStatement(0, {
+                declarationKind: VariableDeclarationKind.Const,
+                declarations: [{ initializer: `useTranslations("${namespace}")`, name: "t" }],
+            });
+        }
+        return;
+    }
+    // Arrow Function Component
+    if (decl.getKind() === SyntaxKind.VariableDeclaration) {
+        const initializer = decl.getInitializer();
+        if (!initializer)
+            return;
+        // Si es arrow function
+        if (initializer.getKind() === SyntaxKind.ArrowFunction) {
+            const body = initializer.asKind(SyntaxKind.ArrowFunction)?.getBody();
+            if (!body)
+                return;
+            // Si es un bloque {}
+            if (body.getKind() === SyntaxKind.Block && !body.getVariableStatements().some(vs => vs.getDeclarations().some(d => d.getName() === "t"))) {
+                body.insertVariableStatement(0, {
+                    declarationKind: VariableDeclarationKind.Const, declarations: [{ initializer: `useTranslations("${namespace}")`, name: "t" }],
+                });
+            }
+            decl.setInitializer(`() => { const t = useTranslations("${namespace}"); return ${body.getText()}; }`);
+        }
+    }
+}

package/dist/core/ast/is-translatable.js

@@ -0,0 +1,38 @@
+import { Node } from "ts-morph";
+const IGNORED_PROPS = new Set([
+    "class",
+    "className",
+    "id",
+    "key",
+]);
+export function isTranslatableString(node, text) {
+    const parent = node.getParent();
+    // use client / use server
+    if (text === "use client" || text === "use server") {
+        return false;
+    }
+    // imports
+    if (Node.isImportDeclaration(parent))
+        return false;
+    // JSX attributes (className, id, etc)
+    if (Node.isJsxAttribute(parent)) {
+        const name = parent.getNameNode().getText();
+        if (IGNORED_PROPS.has(name)) {
+            return false;
+        }
+    }
+    // Tailwind heurística (simple y efectiva)
+    if (/^(flex|grid|gap-|bg-|text-|p-|m-|w-|h-)/.test(text)) {
+        return false;
+    }
+    // paths
+    if (text.startsWith("/") || text.startsWith("./")) {
+        return false;
+    }
+    // console.*
+    if (Node.isCallExpression(parent) &&
+        parent.getExpression().getText().startsWith("console.")) {
+        return false;
+    }
+    return true;
+}

package/dist/core/ast/parse-file.js

@@ -0,0 +1,7 @@
+import { Project } from "ts-morph";
+export function parseFile(filePath) {
+    const project = new Project({
+        tsConfigFilePath: "tsconfig.json",
+    });
+    return project.addSourceFileAtPath(filePath);
+}

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

@@ -0,0 +1,32 @@
+import { Node } from "ts-morph";
+const allowedProps = new Set(["alt", "aria-label", "placeholder", "title"]);
+const allowedFunctions = new Set(["alert", "confirm", "prompt"]);
+export function replaceTempKeysWithT(mapped) {
+    for (const { key, node, placeholders = [] } of mapped) {
+        const placeholdersText = placeholders.length > 0
+            ? `{ ${placeholders.map(p => `${p}: ${p}`).join(", ")} }`
+            : "";
+        if (Node.isJsxText(node)) {
+            // JSXText → {t("key")}
+            node.replaceWithText(`{t("${key}"${placeholdersText ? `, ${placeholdersText}` : ""})}`);
+        }
+        else if (Node.isStringLiteral(node)) {
+            const parent = node.getParent();
+            if (Node.isJsxAttribute(parent) && allowedProps.has(parent.getNameNode().getText())) {
+                // Props de JSX → {t("key")}
+                node.replaceWithText(`{t("${key}"${placeholdersText ? `, ${placeholdersText}` : ""})}`);
+            }
+            else if (Node.isCallExpression(parent) && allowedFunctions.has(parent.getExpression().getText())) {
+                // Literal dentro de alert/confirm/prompt → t("key", { ... })
+                node.replaceWithText(`t("${key}"${placeholdersText ? `, ${placeholdersText}` : ""})`);
+            }
+        }
+        else if (Node.isNoSubstitutionTemplateLiteral(node) || Node.isTemplateExpression(node)) {
+            const parent = node.getParent();
+            if (Node.isCallExpression(parent) && allowedFunctions.has(parent.getExpression().getText())) {
+                // Template literal dentro de alert/confirm/prompt
+                node.replaceWithText(`t("${key}"${placeholdersText ? `, ${placeholdersText}` : ""})`);
+            }
+        }
+    }
+}

package/dist/core/i18n/parse-ai-json.js

@@ -0,0 +1,12 @@
+export function parseAiJson(raw) {
+    const cleaned = raw
+        .replaceAll('```json', "")
+        .replaceAll('```', "")
+        .trim();
+    try {
+        return JSON.parse(cleaned);
+    }
+    catch {
+        throw new Error("Gemini did not return valid JSON");
+    }
+}

package/dist/core/i18n/sace-source-file.js

@@ -0,0 +1,3 @@
+export function saveSourceFile(sourceFile) {
+    sourceFile.saveSync();
+}

package/dist/core/i18n/write-files.js

@@ -0,0 +1,17 @@
+import chalk from "chalk";
+import fs from "node:fs";
+import path from "node:path";
+export function writeLocaleFiles(namespace, data, locales) {
+    for (const locale of locales) {
+        const content = {};
+        content[namespace] = {};
+        for (const key of Object.keys(data[namespace])) {
+            content[namespace][key] = data[namespace][key][locale];
+        }
+        const dir = path.join(process.cwd(), "messages", locale);
+        fs.mkdirSync(dir, { recursive: true });
+        const filePath = path.join(dir, `${namespace}.json`);
+        fs.writeFileSync(filePath, JSON.stringify(content, null, 2));
+        console.log(chalk.green(`💾 Locale file saved: ${filePath}`));
+    }
+}

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/oclif.manifest.json

@@ -0,0 +1,165 @@
+{
+  "commands": {
+    "extract": {
+      "aliases": [],
+      "args": {
+        "file": {
+          "description": "Path to the TSX/JSX file",
+          "name": "file",
+          "required": true
+        }
+      },
+      "description": "🌍 Extract translatable strings from a TSX/JSX file and generate i18n JSON",
+      "flags": {
+        "locales": {
+          "char": "l",
+          "description": "Locales to generate",
+          "name": "locales",
+          "default": "en,es",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "provider": {
+          "char": "p",
+          "description": "AI provider (gemini | huggingface), optional",
+          "name": "provider",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "extract",
+      "pluginAlias": "i18nizer",
+      "pluginName": "i18nizer",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "extract.js"
+      ]
+    },
+    "keys": {
+      "aliases": [],
+      "args": {},
+      "description": "Manage API keys for your CLI",
+      "flags": {
+        "setGemini": {
+          "char": "g",
+          "description": "Set Google Gemini API key",
+          "name": "setGemini",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "setHF": {
+          "char": "h",
+          "description": "Set Hugging Face API key",
+          "name": "setHF",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "setOpenAI": {
+          "char": "o",
+          "description": "Set OpenAI API key",
+          "name": "setOpenAI",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "show": {
+          "char": "s",
+          "description": "Show saved keys (masked)",
+          "name": "show",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "keys",
+      "pluginAlias": "i18nizer",
+      "pluginName": "i18nizer",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "keys.js"
+      ]
+    },
+    "hello": {
+      "aliases": [],
+      "args": {
+        "person": {
+          "description": "Person to say hello to",
+          "name": "person",
+          "required": true
+        }
+      },
+      "description": "Say hello",
+      "examples": [
+        "<%= config.bin %> <%= command.id %> friend --from oclif\nhello friend from oclif! (./src/commands/hello/index.ts)\n"
+      ],
+      "flags": {
+        "from": {
+          "char": "f",
+          "description": "Who is saying hello",
+          "name": "from",
+          "required": true,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "hello",
+      "pluginAlias": "i18nizer",
+      "pluginName": "i18nizer",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "hello",
+        "index.js"
+      ]
+    },
+    "hello:world": {
+      "aliases": [],
+      "args": {},
+      "description": "Say hello world",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>\nhello world! (./src/commands/hello/world.ts)\n"
+      ],
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "hello:world",
+      "pluginAlias": "i18nizer",
+      "pluginName": "i18nizer",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "hello",
+        "world.js"
+      ]
+    }
+  },
+  "version": "0.1.0"
+}

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "i18nizer",
+  "description": "CLI to extract texts from JSX/TSX and generate i18n JSON with AI translations",
+  "version": "0.1.0",
+  "author": "Yoannis Sanchez Soto",
+  "bin": "./bin/run.js",
+  "bugs": "https://github.com/tools/i18nizer/issues",
+  "dependencies": {
+    "@google/genai": "^1.34.0",
+    "@huggingface/inference": "^4.13.5",
+    "@oclif/core": "^4",
+    "@oclif/plugin-help": "^6",
+    "@oclif/plugin-plugins": "^5",
+    "chalk": "^5.6.2",
+    "node-fetch": "^3.3.2",
+    "openai": "^6.15.0",
+    "ora": "^9.0.0",
+    "ts-morph": "^27.0.2"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^1",
+    "@oclif/prettier-config": "^0.2.1",
+    "@oclif/test": "^4",
+    "@types/chai": "^4",
+    "@types/mocha": "^10",
+    "@types/node": "^18",
+    "chai": "^4",
+    "eslint": "^9",
+    "eslint-config-oclif": "^6",
+    "eslint-config-prettier": "^10",
+    "mocha": "^10",
+    "oclif": "^4",
+    "shx": "^0.3.3",
+    "ts-node": "^10",
+    "typescript": "^5"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "./bin",
+    "./dist",
+    "./oclif.manifest.json"
+  ],
+  "homepage": "https://github.com/tools/i18nizer#readme",
+  "keywords": [
+    "oclif",
+    "i18n",
+    "cli",
+    "translation",
+    "ai",
+    "generative-ai",
+    "google"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "type": "module",
+  "oclif": {
+    "bin": "i18nizer",
+    "dirname": "i18nizer",
+    "commands": "./dist/commands",
+    "plugins": [
+      "@oclif/plugin-help",
+      "@oclif/plugin-plugins"
+    ],
+    "topicSeparator": " ",
+    "topics": {
+      "hello": {
+        "description": "Say hello to the world and others"
+      }
+    }
+  },
+  "repository": "tools/i18nizer",
+  "scripts": {
+    "build": "shx rm -rf dist && tsc -b",
+    "lint": "eslint",
+    "postpack": "shx rm -f oclif.manifest.json",
+    "posttest": "yarn lint",
+    "prepack": "oclif manifest && oclif readme",
+    "test": "mocha --forbid-only \"test/**/*.test.ts\"",
+    "version": "oclif readme && git add README.md"
+  },
+  "types": "dist/index.d.ts",
+  "packageManager": "yarn@4.12.0"
+}