@intlayer/docs 8.12.5-canary.0 → 9.0.0-canary.3

package/docs/en-GB/plugins/sync-json.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-03-13
-updatedAt: 2025-10-05
+updatedAt: 2026-06-21
 title: Sync JSON plugin
 description: Synchronise Intlayer dictionaries with third‑party i18n JSON files (i18next, next-intl, react-intl, vue-i18n, and more). Keep your existing i18n while using Intlayer to manage, translate, and test your messages.
 keywords:
@@ -24,6 +24,9 @@ slugs:
   - sync-json
 youtubeVideo: https://www.youtube.com/watch?v=MpGMxniDHNg
 history:
+  - version: 9.0.0
+    date: 2026-06-21
+    changes: "Add splitKeys option (one dictionary per top-level namespace key) for next-intl / react-intl single-file layouts"
   - version: 7.5.0
     date: 2025-12-13
     changes: "Add ICU and i18next format support"
@@ -41,7 +44,7 @@ Use Intlayer as an add‑on to your existing i18n stack. This plugin keeps your
 
 - Keep i18next, next‑intl, react‑intl, vue‑i18n, next‑translate, nuxt‑i18n, Solid‑i18next, svelte‑i18n, etc.
 - Manage and translate your messages with Intlayer (CLI, CI, providers, CMS), without refactoring your app.
-- Deliver tutorials and SEO content targeting each ecosystem, while recommending Intlayer as the JSON management layer.
+- Deliver tutorials and SEO content targeting each ecosystem, whilst recommending Intlayer as the JSON management layer.
 
 Notes and current scope:
 
@@ -62,7 +65,63 @@ pnpm add -D @intlayer/sync-json-plugin
 npm i -D @intlayer/sync-json-plugin
 ```
 
-## Quick start
+## Plugins
+
+This package provides two plugins:
+
+- `loadJSON`: Load JSON files into Intlayer dictionaries.
+  - This plugin is used to load JSON files from a source and will be loaded into Intlayer dictionaries. It can scan all the codebase and search for specific JSON files.
+    This plugin can be used
+    - if you use an i18n library that imposes a specific location for your JSON to be loaded (ex: `next-intl`, `i18next`, `react-intl`, `vue-i18n`, etc.), but you want to place your content declaration where you want in your code base.
+    - It can also be used if you want to fetch your messages from a remote source (ex: a CMS, an API, etc.) and store your messages in JSON files.
+
+  > Under the hood, this plugin will scan all the codebase and search for specific JSON files and load them into Intlayer dictionaries.
+  > Note that this plugin will not write the output and translations back to the JSON files.
+
+- `syncJSON`: Synchronise JSON files with Intlayer dictionaries.
+  - This plugin is used to synchronise JSON files with Intlayer dictionaries. It can scan the given location and load the JSON that match the pattern for specific JSON files. This plugin is useful if you want to get the benefits of Intlayer whilst using another i18n library.
+
+## Using both plugins
+
+```ts fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON, syncJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+
+  // Keep your current JSON files in sync with Intlayer dictionaries
+  plugins: [
+    /**
+     * Will load all the JSON files in the src that match the pattern {key}.i18n json
+     */
+    loadJSON({
+      source: ({ key }) => `./src/**/${key}.i18n.json`,
+      locale: Locales.ENGLISH,
+      priority: 1, // Ensures these JSON files take precedence over files at `./locales/en/${key}.json`
+      format: "intlayer", // Format of the JSON content
+    }),
+    /**
+     * Will load, and write the output and translations back to the JSON files in the locales directory
+     */
+    syncJSON({
+      format: "i18next",
+      source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      priority: 0,
+      format: "i18next",
+    }),
+  ],
+};
+
+export default config;
+```
+
+## `syncJSON` plugin
+
+### Quick start
 
 Add the plugin to your `intlayer.config.ts` and point it at your existing JSON structure.
 
@@ -81,6 +140,7 @@ const config: IntlayerConfig = {
     syncJSON({
       // Per-locale, per-namespace layout (e.g., next-intl, i18next with namespaces)
       source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      format: "icu",
     }),
   ],
 };
@@ -91,14 +151,27 @@ export default config;
 Alternative: single file per locale (common with i18next/react-intl setups):
 
 ```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale }) => `./locales/${locale}.json`,
-  }),
-];
+import { Locales, type IntlayerConfig } from "intlayer";
+import { syncJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  plugins: [
+    syncJSON({
+      format: "i18next",
+      source: ({ locale }) => `./locales/${locale}.json`,
+      format: "i18next",
+    }),
+  ],
+};
+
+export default config;
 ```
 
-### How it works
+#### How it works
 
 - Read: the plugin discovers JSON files from your `source` builder and loads them as Intlayer dictionaries.
 - Write: after builds and fills, it writes localised JSON back to the same paths (with a final newline to avoid formatting issues).
@@ -112,6 +185,7 @@ syncJSON({
   location?: string, // optional label, default: "plugin"
   priority?: number, // optional priority for conflict resolution, default: 0
   format?: 'intlayer' | 'icu' | 'i18next', // optional formatter, used for intlayer runtime compatibility
+  splitKeys?: boolean, // optional, split a single file into one dictionary per top-level key (auto-detected)
 });
 ```
 
@@ -136,17 +210,49 @@ syncJSON({
 }),
 ```
 
-## Multiple JSON sources and priority
+#### `splitKeys` (boolean)
+
+Controls whether a single JSON file whose **first-level keys are namespaces** should become one dictionary per top-level key, instead of a single dictionary holding the whole file.
+
+This matches the namespace model of libraries like `next-intl` and `react-intl`, where one `messages/{locale}.json` file groups several namespaces by its first-level keys, each addressed independently (e.g. `useTranslations('Hero')` resolves to the `Hero` dictionary).
+
+- `undefined` (default): **auto-detected** — the file is split when the `source` pattern has no `{key}` segment (one file holds every namespace), and kept as a single dictionary otherwise (one file per key).
+- `true`: always split each top-level key into its own dictionary.
+- `false`: never split; the whole file becomes a single dictionary.
+
+Given a single `messages/{locale}.json` file:
+
+```json fileName="messages/en.json"
+{
+  "Hero": { "title": "Full-stack developer" },
+  "Nav": { "work": "Work", "about": "About" },
+  "About": { "lead": "I build apps end to end." }
+}
+```
+
+```ts fileName="intlayer.config.ts"
+syncJSON({
+  format: "icu",
+  source: ({ locale }) => `./messages/${locale}.json`,
+  // splitKeys: true, // implied because the pattern has no `{key}` segment
+}),
+```
+
+This produces three dictionaries — `Hero`, `Nav`, and `About` — so `useTranslations('Hero')` (next-intl) resolves correctly. On write-back, all namespaces are re-assembled into the same per-locale file.
+
+> When you keep the explicit `{key}` segment in your `source` (e.g. `./locales/${locale}/${key}.json`), each file is already one namespace, so splitting is disabled by default.
+
+### Multiple JSON sources and priority
 
 You can add multiple `syncJSON` plugins to synchronise different JSON sources. This is useful when you have multiple i18n libraries or different JSON structures in your project.
 
-### Priority system
+#### Priority system
 
 When multiple plugins target the same dictionary key, the `priority` parameter determines which plugin takes precedence:
 
 - Higher priority numbers win over lower ones
 - Default priority of `.content` files is `0`
-- Default priority of plugins content files is `-1`
+- Default priority of plugins is `0`
 - Plugins with the same priority are processed in the order they appear in the configuration
 
 ```ts fileName="intlayer.config.ts"
@@ -189,7 +295,133 @@ const config: IntlayerConfig = {
 export default config;
 ```
 
-### Conflict resolution
+## Load JSON plugin
+
+### Quick start
+
+Add the plugin to your `intlayer.config.ts` to ingest existing JSON files as Intlayer dictionaries. This plugin is read‑only (no writes to disk):
+
+```ts fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+
+  plugins: [
+    // Ingest JSON messages located anywhere in your source tree
+    loadJSON({
+      source: ({ key }) => `./src/**/${key}.i18n.json`,
+      // Load a single locale per plugin instance (defaults to the config defaultLocale)
+      locale: Locales.ENGLISH,
+      priority: 0,
+    }),
+  ],
+};
+
+export default config;
+```
+
+Alternative: per‑locale layout, still read‑only (only the selected locale is loaded):
+
+```ts fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  plugins: [
+    loadJSON({
+      // Only files for Locales.FRENCH will be loaded from this pattern
+      source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      locale: Locales.FRENCH,
+    }),
+  ],
+};
+
+export default config;
+```
+
+### How it works
+
+- Discover: builds a glob from your `source` builder and collects matching JSON files.
+- Ingest: loads each JSON file as an Intlayer dictionary with the provided `locale`.
+- Read‑only: does not write or format output files; use `syncJSON` if you need round‑trip sync.
+- Auto‑fill ready: defines a `fill` pattern so `intlayer content fill` can populate missing keys.
+
+### API
+
+```ts
+loadJSON({
+  // Build paths to your JSON. `locale` is optional if your structure has no locale segment
+  source: ({ key, locale }) => string,
+
+  // Target locale for the dictionaries loaded by this plugin instance
+  // Defaults to configuration.internationalization.defaultLocale
+  locale?: Locale,
+
+  // Optional label to identify the source
+  location?: string, // default: "plugin"
+
+  // Priority used for conflict resolution against other sources
+  priority?: number, // default: 0
+
+  // Optional formatter for the JSON content
+  format?: 'intlayer' | 'icu' | 'i18next', // default: 'intlayer'
+
+  // Split a single file into one dictionary per top-level key (auto-detected)
+  splitKeys?: boolean,
+});
+```
+
+#### `format` ('intlayer' | 'icu' | 'i18next')
+
+Specifies the formatter to use for the dictionary content when loading JSON files. This allows using different message formatting syntaxes compatible with various i18n libraries.
+
+- `'intlayer'`: The default Intlayer formatter (default).
+- `'icu'`: Uses ICU message formatting (compatible with libraries like react-intl, vue-i18n).
+- `'i18next'`: Uses i18next message formatting (compatible with i18next, next-i18next, Solid-i18next).
+
+**Example:**
+
+```ts
+loadJSON({
+  source: ({ key }) => `./src/**/${key}.i18n.json`,
+  locale: Locales.ENGLISH,
+  format: "icu", // Use ICU formatting for compatibility
+}),
+```
+
+#### `splitKeys` (boolean)
+
+Same behaviour as in [`syncJSON`](#splitkeys-boolean): when a single JSON file groups several namespaces by its first-level keys, each top-level key becomes its own dictionary.
+
+- `undefined` (default): **auto-detected** — split when the `source` pattern has no `{key}` segment, single dictionary otherwise.
+- `true` / `false`: force or disable splitting.
+
+```ts
+loadJSON({
+  source: ({ locale }) => `./messages/${locale}.json`,
+  format: "icu",
+  // splitKeys auto-enabled: `Hero`, `Nav`, `About`, … each become a dictionary
+}),
+```
+
+### Behavior and conventions
+
+- If your `source` mask includes a locale placeholder, only files for the selected `locale` are ingested.
+- If there is no `{key}` segment in your mask, each top-level key of the file becomes its own dictionary by default (see [`splitKeys`](#splitkeys-boolean)). Set `splitKeys: false` to instead load the whole file as a single `index` dictionary.
+- Keys are derived from file paths by substituting the `{key}` placeholder in your `source` builder.
+- The plugin only uses discovered files and does not fabricate missing locales or keys.
+- The `fill` path is inferred from your `source` and used to update missing values via CLI when you opt‑in.
+
+## Conflict resolution
 
 When the same translation key exists in multiple JSON sources:
 

package/docs/en-GB/releases/v8.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-09-22
-updatedAt: 2026-01-26
+updatedAt: 2026-06-14
 title: New Intlayer v8 - What's new?
 description: Discover what's new in Intlayer v8. Major improvements in developer experience, content validation, and dictionary management.
 keywords:

package/docs/en-GB/releases/v9.md

@@ -0,0 +1,220 @@
+---
+createdAt: 2026-06-14
+updatedAt: 2026-06-14
+title: New Intlayer v9 - What's new?
+description: Discover what's new in Intlayer v9. Introducing drop-in compatibility packages for popular i18n libraries and support for Collections, Variants, and Dynamic Records.
+keywords:
+  - Intlayer
+  - Compatibility
+  - Migration
+  - Collections
+  - Variants
+  - Dynamic Records
+  - i18next
+  - next-intl
+  - vue-i18n
+slugs:
+  - doc
+  - releases
+  - v9
+author: aymericzip
+---
+
+# New Intlayer v9 - What's new?
+
+Welcome to Intlayer v9! This major release marks a huge milestone in simplifying the migration path to Intlayer with **Compat Adapter Packages** for major i18n libraries (`react-i18next`, `next-intl`, `vue-i18n`, etc.) and adds support for rich content structures: **Collections**, **Variants**, and **Dynamic Records**.
+
+## Table of contents
+
+<TOC levels={[2]} maxDepth={1} />
+
+---
+
+## Compat Adapter Packages
+
+Migrating to Intlayer from popular i18n libraries is now easier than ever. We have created five compat packages that expose the **exact same public APIs** as standard i18n libraries but delegate all translation work to Intlayer at runtime.
+
+### Expose Same Public API with Strict Typing
+
+By replacing imports, you get all the benefits of Intlayer (including compile-time type safety against your actual dictionaries) with minimal code changes:
+
+- `@intlayer/i18next`
+- `@intlayer/react-i18next`
+- `@intlayer/next-intl`
+- `@intlayer/next-i18next`
+- `@intlayer/vue-i18n`
+
+For example, simply change:
+
+```ts
+import { useTranslation } from "react-i18next";
+```
+
+to:
+
+```ts
+import { useTranslation } from "@intlayer/react-i18next";
+```
+
+Your keys will now be **strictly typed** against your Intlayer dictionaries, offering full dot-path auto-completion in your IDE!
+
+### Bundler Alias Plugins (Vite, Next.js, Turbopack)
+
+To allow migrating without rewriting all your import statements manually, each compat adapter package includes a **custom bundler plugin** (Vite or Next.js) under the `/plugin` subpath.
+
+These plugins automatically rewrite existing imports (e.g. `react-i18next` or `next-intl`) to their `@intlayer/*` equivalents at build time.
+
+#### Next.js (Webpack / Turbopack) Example
+
+Instead of `withIntlayer`, wrap your Next.js configuration with the compat plugin:
+
+```ts fileName="next.config.ts"
+import { createNextI18nPlugin } from "@intlayer/next-i18next/plugin";
+import type { NextConfig } from "next";
+
+const withIntlayer = createNextI18nPlugin();
+const nextConfig: NextConfig = {};
+
+export default withIntlayer(nextConfig);
+```
+
+#### Vite (React, Vue, Solid, Svelte) Example
+
+```ts fileName="vite.config.ts"
+import vueI18nVitePlugin from "@intlayer/vue-i18n/plugin";
+
+export default defineConfig({
+  plugins: [vueI18nVitePlugin()],
+});
+```
+
+---
+
+## Mutualized Runtime Resolver
+
+All compat adapters now route translation resolution through a single, highly optimised runtime parser: `@intlayer/core/messageFormat`.
+
+- **Interpolate Message**: Resolves standard `{{var}}` (whitespace & dot-paths), ICU formatted args (`{v, number, percent}` etc.), and bare `{var}` templates.
+- **Message Node Resolver**: Resolves nested nodes: `insert()`, `plural()` (CLDR plural rules), `enu()` (enumeration), `gender()`, HTML tags, arrays, and callable function nodes.
+- **Tokenised Tag Parser**: Supports inline XML/HTML tags and numbered tags (e.g., `<1>children</1>`) to power rich-text rendering out of the box.
+
+---
+
+## Feature Spec: Collections, Variants & Dynamic Records
+
+Intlayer v9 expands beyond static key-value objects, allowing dictionaries to declare dynamic layout structures that are fully typed end-to-end.
+
+### 1. Collections
+
+Define a CMS-managed list of ordered items (e.g. FAQs, products, or blog lists):
+
+```ts fileName="faq.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "faq",
+  content: [
+    {
+      question: t({ en: "What is Intlayer?", fr: "Qu'est-ce qu'Intlayer ?" }),
+      answer: t({ en: "An i18n toolkit.", fr: "Une boîte à outils i18n." }),
+    },
+  ],
+} satisfies Dictionary;
+```
+
+#### Usage:
+
+```ts
+// Fetch all items
+const allFaqs = useIntlayer("faq"); // -> { question: string, answer: string }[]
+
+// Fetch single item by index
+const faq = useIntlayer("faq", { item: 1 }); // -> { question: string, answer: string }
+```
+
+### 2. Variants
+
+Deliver A/B tests, seasonal headers, feature flags, or custom landing pages:
+
+```ts fileName="hero.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "hero-banner",
+  variant: "default",
+  content: {
+    control: t({ en: "Welcome", fr: "Bienvenue" }),
+    black_friday: t({ en: "Shop now", fr: "Acheter maintenant" }),
+  },
+} satisfies Dictionary;
+```
+
+#### Usage:
+
+```ts
+const banner = useIntlayer("hero-banner", { variant: "black_friday" });
+```
+
+### 3. Dynamic Records
+
+Define dictionaries whose entries are loaded dynamically at runtime via query IDs:
+
+```ts fileName="product.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "product-copy",
+  meta: {
+    id: "prod_123",
+    category: "books",
+  },
+  content: {
+    title: t({ en: "Clean Code", fr: "Code Propre" }),
+  },
+} satisfies Dictionary;
+```
+
+#### Usage:
+
+```ts
+// Fetches only the requested item dynamically (requires Suspense)
+const product = useIntlayer("product-copy", {
+  id: "prod_123",
+  category: "books",
+});
+```
+
+---
+
+## Dynamic Loading & Bundle Size Optimisations
+
+To keep bundles extremely small, Intlayer v9 supports dynamic lazy loading.
+
+In your configuration, set `importMode` to `'dynamic'` or `'fetch'`:
+
+```ts fileName="intlayer.config.ts"
+export default {
+  dictionary: {
+    importMode: "dynamic", // "static" | "dynamic" | "fetch"
+  },
+};
+```
+
+At build time, `@intlayer/swc` and `@intlayer/babel` scan your files and replace `useIntlayer` / `getIntlayer` calls with tree-shakeable wrappers (`useDictionary` / `useDictionaryDynamic`). Only the content required for the selected collection item, variant, or locale is loaded, preventing your production bundle from containing unused translations.
+
+---
+
+## Migration notes from v8
+
+If you are upgrading from v8, note that the v9 does not include breaking changes. But here are the key changes:
+
+- **Locales & Dialects**: If using external i18n dependencies, add their respective compat adapter plugins in your configuration or bundler setup to automatically rewrite imports.
+- **Custom Selectors**: When calling `useIntlayer`, the second parameter is now reserved for an option object containing `{ locale, item, variant, id }`. If you previously passed a locale string directly, you can still do so, but using the options object is recommended for advanced selections.
+
+---
+
+## Useful links
+
+- [Compat Adapter Packages Guide](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/compat/index.md)
+- [Dynamic Dictionaries - Collections, Variants & Dynamic Records](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/dynamic_dictionaries/index.md)
+- [Configuration Reference](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/configuration.md)

package/docs/es/cli/doc-review.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-11
-updatedAt: 2025-11-22
+updatedAt: 2026-06-17
 title: Revisar Documento
 description: Aprende cómo revisar archivos de documentación para calidad, consistencia y completitud en diferentes locales.
 keywords:
@@ -15,6 +15,10 @@ slugs:
   - concept
   - cli
   - doc-review
+history:
+  - version: 9.0.0
+    date: 2026-06-17
+    changes: "Añadir opción --log"
 author: aymericzip
 ---
 
@@ -55,8 +59,110 @@ Para la mayoría de los casos de uso,
 
 ## Argumentos:
 
-El comando `doc review` acepta los mismos argumentos que `doc translate`, permitiéndote revisar archivos de documentación específicos y aplicar controles de calidad.
+**Opciones de lista de archivos:**
 
-Si activaste una de las opciones de git, el comando solo revisará la parte de los archivos que están siendo modificados. El script procesará el archivo dividiéndolo en fragmentos y revisará cada fragmento. Si no hay cambios en el fragmento, el script lo omitirá para acelerar el proceso de revisión y limitar el costo de la API del proveedor de IA.
+- **`--doc-pattern [docPattern...]`**: Patrones glob para coincidir con archivos de documentación a revisar.
 
-Para una lista completa de argumentos, consulta la documentación del comando [Translate Document](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/cli/doc-translate.md).
+  > Ejemplo: `npx intlayer doc review --doc-pattern "docs/**/*.md" "src/**/*.mdx"`
+
+- **`--excluded-glob-pattern [excludedGlobPattern...]`**: Patrones glob para excluir archivos de la revisión.
+
+  > Ejemplo: `npx intlayer doc review --excluded-glob-pattern "docs/internal/**"`
+
+- **`--skip-if-modified-before [skipIfModifiedBefore]`**: Omitir el archivo si ha sido modificado antes del tiempo dado.
+  - Puede ser un tiempo absoluto como "2025-12-05" (string o Date)
+  - Puede ser un tiempo relativo en ms `1 * 60 * 60 * 1000` (1 hora)
+  - Esta opción verifica la hora de actualización del archivo usando el método `fs.stat`. Por lo tanto, podría verse afectada por Git u otras herramientas que modifiquen el archivo.
+
+  > Ejemplo: `npx intlayer doc review --skip-if-modified-before "2025-12-05"`
+
+- **`--skip-if-modified-after [skipIfModifiedAfter]`**: Omitir el archivo si ha sido modificado dentro del tiempo dado.
+  - Puede ser un tiempo absoluto como "2025-12-05" (string o Date)
+  - Puede ser un tiempo relativo en ms `1 * 60 * 60 * 1000` (1 hora)
+  - Esta opción verifica la hora de actualización del archivo usando el método `fs.stat`. Por lo tanto, podría verse afectada por Git u otras herramientas que modifiquen el archivo.
+
+  > Ejemplo: `npx intlayer doc review --skip-if-modified-after "2025-12-05"`
+
+- **`--skip-if-exists`**: Omitir el archivo si ya existe.
+
+  > Ejemplo: `npx intlayer doc review --skip-if-exists`
+
+**Opciones de modo de revisión:**
+
+- **`--log`**: Modo de solo registro. No traduce con IA; en su lugar, registra los bloques que necesitan atención (con números de línea y contenido) para los locales base y destino, para ayudar a otro agente a generar las traducciones.
+
+  > Ejemplo: `npx intlayer doc review --log`
+
+**Opciones de salida de entrada:**
+
+- **`--locales [locales...]`**: Locales de destino para revisar la documentación.
+
+  > Ejemplo: `npx intlayer doc review --locales fr es de`
+
+- **`--base-locale [baseLocale]`**: Locale de origen (documento base) contra el cual comparar.
+
+  > Ejemplo: `npx intlayer doc review --base-locale en`
+
+**Opciones de procesamiento de archivos:**
+
+- **`--nb-simultaneous-file-processed [nbSimultaneousFileProcessed]`**: Número de archivos a procesar simultáneamente para la revisión.
+
+  > Ejemplo: `npx intlayer doc review --nb-simultaneous-file-processed 5`
+
+**Opciones de IA:**
+
+- **`--model [model]`**: El modelo de IA a usar para la revisión (por ejemplo, `gpt-3.5-turbo`).
+- **`--provider [provider]`**: El proveedor de IA a usar para la revisión.
+- **`--temperature [temperature]`**: Configuración de temperatura para el modelo de IA.
+- **`--api-key [apiKey]`**: Proporciona tu propia clave API para el servicio de IA.
+- **`--application-context [applicationContext]`**: Proporciona contexto adicional para la revisión de IA.
+- **`--data-serialization [dataSerialization]`**: El formato de serialización de datos a utilizar para las funciones de IA de Intlayer. Opciones: `json` (estándar, confiable), `toon` (menos tokens, menos consistente).
+- **`--custom-prompt [prompt]`**: Personaliza el prompt base utilizado para la revisión. (Nota: Para la mayoría de los casos, se recomienda usar la opción `--custom-instructions` en su lugar, ya que proporciona un mejor control.)
+
+  > Ejemplo: `npx intlayer doc review --model deepseek-chat --provider deepseek --temperature 0.5 --api-key sk-1234567890 --application-context "Mi aplicación es una tienda de gatos"`
+
+**Opciones de variables de entorno:**
+
+- **`--env`**: Especifica el entorno (por ejemplo, `development`, `production`).
+- **`--env-file [envFile]`**: Proporciona un archivo de entorno personalizado para cargar variables.
+- **`--base-dir`**: Especifica el directorio base para el proyecto.
+- **`--no-cache`**: Desactiva la caché.
+
+  > Ejemplo: `npx intlayer doc review --base-dir ./docs --env-file .env.production.local`
+
+**Opciones de registro:**
+
+- **`--verbose`**: Habilita el registro detallado para depuración. (por defecto es true usando CLI)
+
+  > Ejemplo: `npx intlayer doc review --verbose`
+
+**Opciones de instrucciones personalizadas:**
+
+- **`--custom-instructions [customInstructions]`**: Instrucciones personalizadas añadidas al prompt. Útil para aplicar reglas específicas respecto al formato, traducción de URLs, etc.
+
+  > Ejemplo: `npx intlayer doc review --custom-instructions "Evitar traducir URLs y mantener el formato markdown"`
+
+  > Ejemplo: `npx intlayer doc review --custom-instructions "$(cat ./instructions.md)"`
+
+**Opciones de Git:**
+
+- **`--git-diff`**: Ejecutar solo en archivos que incluyan cambios desde la base (por defecto `origin/main`) hasta la rama actual (por defecto: `HEAD`).
+- **`--git-diff-base`**: Especificar la referencia base para git diff (por defecto `origin/main`).
+- **`--git-diff-current`**: Especificar la referencia actual para git diff (por defecto: `HEAD`).
+- **`--uncommitted`**: Incluir cambios no confirmados.
+- **`--unpushed`**: Incluir cambios no enviados.
+- **`--untracked`**: Incluir archivos no rastreados.
+
+  > Ejemplo: `npx intlayer doc review --git-diff --git-diff-base origin/main --git-diff-current HEAD`
+
+  > Ejemplo: `npx intlayer doc review --uncommitted --unpushed --untracked`
+
+> Tenga en cuenta que la ruta del archivo de salida se determinará reemplazando los siguientes patrones:
+>
+> - `/{{baseLocale}}/` por `/{{locale}}/` (Unix)
+> - `\{{baseLocale}}\` por `\{{locale}}\` (Windows)
+> - `_{{baseLocale}}.` por `_{{locale}}.`
+> - `{{baseLocale}}_` por `{{locale}}_`
+> - `.{{baseLocaleName}}.` por `.{{localeName}}.`
+>
+> Si no se encuentra el patrón, el archivo de salida añadirá `.{{locale}}` a la extensión del archivo. `./my/file.md` se revisará y actualizará a `./my/file.fr.md` para el locale francés.