glotto 2.9.0 → 3.1.0

package/README.md

@@ -1,32 +1,18 @@
 # Glotto AI Translator
 
-Glotto is a powerful tool designed to translate i18n JSON files using advanced AI technology. It streamlines the localization process by automatically
-translating your language files to any target language while maintaining the JSON structure.
-
-## Features
-
-- Translate JSON files while preserving the original structure
-- Support for multiple language pairs
-- Configurable batch processing with customizable key limits
-- Command-line interface for easy integration into your workflow
+Glotto translates i18n JSON files (i18next, react-intl, vue-i18n, etc.) using AI providers without forcing the model to produce JSON. It walks the input JSON,
+extracts every string leaf with its path, sends them to the model as plain-text tagged batches, and reconstructs the JSON from the responses. The original
+structure, keys, arrays, variables and HTML tags are preserved by Glotto itself — the model only sees and produces text.
 
 ## Installation
 
-Glotto can be installed and used through either JSR (Deno) or npm. Choose the method that best suits your development environment.
-
 ### [JSR (Deno)](https://jsr.io/@ibodev/glotto)
 
-#### Global Installation
-
-Install Glotto globally to use it as a CLI tool from anywhere:
-
 ```bash
 deno install --global --name glotto -A jsr:@ibodev/glotto
 ```
 
-#### Direct Execution
-
-Alternatively, run Glotto directly without installation:
+Or run without installing:
 
 ```bash
 deno run -A jsr:@ibodev/glotto
@@ -34,93 +20,203 @@ deno run -A jsr:@ibodev/glotto
 
 ### [npm (Node)](https://www.npmjs.com/package/glotto)
 
-#### Global Installation
+```bash
+npm install --global glotto
+```
 
-Install Glotto globally via npm to use it as a CLI tool:
+Or via npx:
 
 ```bash
-npm install --global glotto
+npx glotto
 ```
 
-After installation, the `glotto` command will be available in your terminal.
+### [pnpm](https://pnpm.io/)
 
-#### Direct Execution
+```bash
+pnpm add --global glotto
+```
 
-Run Glotto directly using npx without installation:
+Or via pnpx:
 
 ```bash
-npx glotto
+pnpx glotto
 ```
 
 ## Usage
 
-### Basic usage (default Gemini)
+### Basic (default OpenAI)
 
 ```bash
-glotto --key <gemini-api-key> -i en.json -o ar.json -f English -t Arabic
+glotto --key <openai-api-key> -i en.json -o tr.json -f English -t Turkish
 ```
 
-### Use OpenAI instead of Gemini
+### Gemini
 
 ```bash
-glotto --key <openai-api-key> --input=en.json --output=tr.json --from=English --to=Turkish -p openai
+glotto --key <gemini-api-key> -i en.json -o ar.json -f English -t Arabic -p gemini
 ```
 
-Optional custom OpenAI base URL:
+### OpenAI / OpenAI-compatible endpoints
 
 ```bash
-glotto --key <openai-api-key> --input=en.json --output=tr.json --from=English --to=Turkish -p openai --url=https://api.openai.com/v1
+glotto --key <openai-api-key> -i en.json -o tr.json -f English -t Turkish -p openai
 ```
 
-### Use Anthropic (Claude)
+Custom base URL (e.g. self-hosted OpenAI-compatible server):
 
 ```bash
-glotto --key <anthropic-api-key> --input=en.json --output=tr.json --from=English --to=Turkish -p anthropic
+glotto --key <key> -i en.json -o tr.json -f English -t Turkish \
+  -p openai -m <model-name> --url <base-url>
 ```
 
-Optional custom Anthropic base URL:
+### Anthropic (Claude)
 
 ```bash
-glotto --key <anthropic-api-key> --input=en.json --output=tr.json --from=English --to=Turkish -p anthropic --url=https://api.anthropic.com
+glotto --key <anthropic-api-key> -i en.json -o tr.json -f English -t Turkish -p anthropic
 ```
 
-Override default model for a provider:
+### Override the model
 
 ```bash
-glotto --key <openai-api-key> --input=en.json --output=tr.json --from=English --to=Turkish -p openai -m gpt-4.1
+glotto --key <key> -i en.json -o tr.json -f English -t Turkish -p openai -m <model-name>
 ```
 
-### Parameters
+### Multi-target — translate to several languages in one run
 
-- `--key`: API key for the selected AI provider
-- `--input` or `-i`: Source JSON file
-- `--output` or `-o`: Target JSON file
-- `--from` or `-f`: Source language
-- `--to` or `-t`: Target language
-- `--provider` or `-p`: AI provider (`gemini` | `openai` | `anthropic`, default: `gemini`)
-- `--model` or `-m`: Model name for the selected provider (defaults: `gemini-2.5-flash`, `gpt-4.1-mini`, `claude-3-5-haiku-latest`)
-- `--url`: Custom base URL for OpenAI/Anthropic (optional)
+Pass comma-separated values to `-t/--to` and `-o/--output`. The two lists must have the same length; entries pair up by index.
 
-## Development
+```bash
+glotto --key <key> -i en.json -f English \
+  -t "Turkish,French,German" \
+  -o "tr.json,fr.json,de.json"
+```
+
+### Incremental — translate only missing keys
+
+When `--incremental` is set and the target file already exists, Glotto compares it against the source and only sends keys whose target value is missing or
+empty. The existing target structure is preserved; only the missing values are filled in.
 
-To run the project in development mode:
+```bash
+glotto --key <key> -i en.json -o tr.json -f English -t Turkish --incremental
+```
+
+If the target file does not exist, Glotto falls back to a full translation.
+
+### Stats — see token usage
+
+`--stats` prints input/output token totals, call counts, batch sizes and per-target breakdown after the run finishes. Off by default.
 
 ```bash
-deno task cli --key <gemini-or-openai-api-key> --input=en.json --output=tr.json --from=English --to=Turkish -p gemini
+glotto --key <key> -i en.json -o tr.json -f English -t Turkish --stats
 ```
 
-### Building the Project
+### Config file (`glotto.config.json`)
+
+You can keep flags in a config file so you don't have to retype them. Glotto looks for `glotto.config.json` in the current working directory by default; pass
+`--config <path>` to use a custom location. CLI flags always override config values.
+
+Reference the JSON Schema for editor autocompletion and validation:
+
+```json
+{
+  "$schema": "https://raw.githubusercontent.com/ibodev1/glotto/main/schema/glotto.schema.json",
+  "provider": "openai",
+  "model": "gpt-4.1-mini",
+  "input": "locales/en.json",
+  "from": "English",
+  "to": ["Turkish", "French", "German"],
+  "output": ["locales/tr.json", "locales/fr.json", "locales/de.json"],
+  "incremental": true,
+  "stats": true
+}
+```
 
-To create a production build:
+With this config you only need to provide the API key on the CLI:
+
+```bash
+glotto --key <key>
+```
+
+### Disable rate-limit delay and request timeout
+
+```bash
+glotto --key <key> -i en.json -o tr.json -f English -t Turkish --no-limit --no-timeout
+```
+
+### Tune batch size
+
+`--max-batch-size` is the maximum source bytes per batch, in KB. Smaller batches mean more requests but lower per-request token cost; larger batches mean fewer
+requests.
+
+```bash
+glotto --key <key> -i en.json -o tr.json -f English -t Turkish --max-batch-size 8
+```
+
+## Parameters
+
+| Flag               | Description                                                                          |
+| ------------------ | ------------------------------------------------------------------------------------ |
+| `--key`            | API key for the chosen provider (required)                                           |
+| `-p`, `--provider` | `gemini` \| `openai` \| `anthropic` (default `openai`)                               |
+| `-m`, `--model`    | Model name (defaults: `gpt-4.1-mini`, `gemini-2.5-flash`, `claude-3-5-haiku-latest`) |
+| `-i`, `--input`    | Source JSON file (required)                                                          |
+| `-o`, `--output`   | Target JSON file path. Comma-separated for multi-target (required)                   |
+| `-f`, `--from`     | Source language                                                                      |
+| `-t`, `--to`       | Target language. Comma-separated for multi-target                                    |
+| `--url`            | Custom base URL for OpenAI/Anthropic                                                 |
+| `--config`         | Path to a config file (default: `./glotto.config.json` if present)                   |
+| `--stats`          | Print AI usage stats (tokens, calls, bytes) at the end                               |
+| `--incremental`    | Translate only missing/empty keys when the target already exists                     |
+| `--no-limit`       | Skip the inter-batch rate-limit delay                                                |
+| `--no-timeout`     | Disable request timeout                                                              |
+| `--max-batch-size` | Max source bytes per batch in KB (default 12)                                        |
+| `-h`, `--help`     | Help                                                                                 |
+| `-v`, `--version`  | Version                                                                              |
+
+## Config file fields
+
+`glotto.config.json` accepts the keys below. CLI flags override config values.
+
+| Key            | Type                                | Notes                                   |
+| -------------- | ----------------------------------- | --------------------------------------- |
+| `key`          | string                              | API key                                 |
+| `provider`     | `openai` \| `gemini` \| `anthropic` |                                         |
+| `model`        | string                              |                                         |
+| `input`        | string                              | Source JSON path                        |
+| `from`         | string                              | Source language                         |
+| `to`           | string \| string[]                  | Single target or array for multi-target |
+| `output`       | string \| string[]                  | Must match `to` length when array       |
+| `url`          | string                              | Custom base URL                         |
+| `noLimit`      | boolean                             |                                         |
+| `noTimeout`    | boolean                             |                                         |
+| `maxBatchSize` | integer (KB)                        |                                         |
+| `stats`        | boolean                             |                                         |
+| `incremental`  | boolean                             |                                         |
+
+## Development
+
+Run from source:
+
+```bash
+deno task cli --key <key> -i en.json -o tr.json -f English -t Turkish
+```
+
+Build a single-file binary:
 
 ```bash
 deno task build
 ```
 
-## Contributing
+Build npm package:
+
+```bash
+deno task build:npm
+```
+
+## Star us
 
-Contributions are welcome! Feel free to submit issues and pull requests.
+If Glotto saves you time, consider giving it a ⭐ on [GitHub](https://github.com/ibodev1/glotto) — it really helps the project reach more people.
 
 ## License
 
-MIT Licence @ 2026
+MIT © 2026

package/esm/cli.js

@@ -3,8 +3,11 @@ import "./_dnt.polyfills.js";
 import * as dntShim from "./_dnt.shims.js";
 import { Spinner } from './deps/jsr.io/@std/cli/1.0.29/unstable_spinner.js';
 import { parseArgs } from './deps/jsr.io/@std/cli/1.0.29/mod.js';
-import { getImportJson, resolvePath, splitJson, writeOutput } from './src/file.js';
-import { DEFAULT_PROVIDER, HELP_TEXT } from './src/contants.js';
+import { getImportJson, readJsonIfExists, resolvePath, writeOutput } from './src/file.js';
+import { extractLeaves, groupIntoBatches, reconstruct, runBatches } from './src/translator.js';
+import { findMissingLeaves, mergeTranslations } from './src/diff.js';
+import { applyConfig, loadConfig } from './src/config.js';
+import { DEFAULT_MAX_BATCH_BYTES, DEFAULT_PROVIDER, GITHUB_REPO_URL, HELP_TEXT } from './src/contants.js';
 import { formatBytes, validateArgs } from './src/utilites.js';
 import { logger } from './src/logger.js';
 import denoJson from './deno.js';
@@ -12,11 +15,110 @@ import Gemini from './src/providers/gemini.js';
 import OpenAIModel from './src/providers/openai.js';
 import AnthropicModel from './src/providers/anthropic.js';
 const spinner = new Spinner({ message: 'AI Thinks...', color: 'cyan' });
+function createTranslator(args, options) {
+    switch (args.provider) {
+        case 'gemini':
+            return new Gemini(args.key, args.model, options);
+        case 'openai':
+            return new OpenAIModel(args.key, args.url, args.model, options);
+        case 'anthropic':
+            return new AnthropicModel(args.key, args.url, args.model, options);
+        default:
+            throw new Error(`Unknown provider: ${args.provider}`);
+    }
+}
+function printBanner() {
+    logger.box(`Glotto AI Translator v${denoJson.version}\n${GITHUB_REPO_URL}`);
+}
+function printStats(args, perTarget) {
+    const totalInput = perTarget.reduce((sum, t) => sum + t.usage.inputTokens, 0);
+    const totalOutput = perTarget.reduce((sum, t) => sum + t.usage.outputTokens, 0);
+    const totalCalls = perTarget.reduce((sum, t) => sum + t.calls, 0);
+    const totalBytes = perTarget.reduce((sum, t) => sum + t.bytes, 0);
+    const totalTranslated = perTarget.reduce((sum, t) => sum + t.translatedCount, 0);
+    const lines = [];
+    lines.push(`Provider: ${args.provider}${args.model ? ` (${args.model})` : ''}`);
+    lines.push(`Targets: ${perTarget.length}`);
+    lines.push('');
+    for (const t of perTarget) {
+        const mode = t.incrementalApplied ? ' [incremental]' : '';
+        lines.push(`→ ${t.to} (${t.output})${mode}: ${t.translatedCount}/${t.fullCount} entries, ${t.batchCount} batch(es), ${formatBytes(t.bytes)}, ${t.calls} call(s)`);
+        lines.push(`   tokens — in: ${t.usage.inputTokens}, out: ${t.usage.outputTokens}`);
+    }
+    lines.push('');
+    lines.push(`Total: ${totalTranslated} entries translated, ${totalCalls} call(s), ${formatBytes(totalBytes)}`);
+    lines.push(`Total tokens — in: ${totalInput}, out: ${totalOutput}, sum: ${totalInput + totalOutput}`);
+    logger.box(lines.join('\n'));
+}
+async function translateForTarget(validatedArgs, fileContent, allLeaves, to, outputRel, translator, translateOptions, targetIndex, totalTargets) {
+    const outputPath = resolvePath(outputRel);
+    const targetLabel = `[Target ${targetIndex + 1}/${totalTargets}: ${to}]`;
+    logger.info(`${targetLabel} → ${outputRel}`);
+    const translatableLeaves = allLeaves.filter((leaf) => leaf.translatable);
+    let leavesToTranslate = translatableLeaves;
+    let existingTarget = null;
+    let incrementalApplied = false;
+    if (validatedArgs.incremental) {
+        existingTarget = await readJsonIfExists(outputPath);
+        if (existingTarget !== null) {
+            leavesToTranslate = findMissingLeaves(allLeaves, existingTarget);
+            incrementalApplied = true;
+            logger.info(`${targetLabel} Incremental: ${leavesToTranslate.length}/${translatableLeaves.length} entries missing in existing target`);
+        }
+        else {
+            logger.info(`${targetLabel} Incremental: target file not found, doing full translation`);
+        }
+    }
+    if (leavesToTranslate.length === 0) {
+        logger.info(`${targetLabel} Nothing to translate, writing existing/source content`);
+        const content = existingTarget !== null ? existingTarget : fileContent;
+        await writeOutput(outputPath, JSON.stringify(content, null, 2));
+        return {
+            to,
+            output: outputRel,
+            fullCount: translatableLeaves.length,
+            translatedCount: 0,
+            batchCount: 0,
+            bytes: 0,
+            calls: 0,
+            usage: { inputTokens: 0, outputTokens: 0 },
+            incrementalApplied,
+        };
+    }
+    const batches = groupIntoBatches(leavesToTranslate, validatedArgs.maxBatchBytes);
+    const totalBytes = batches.reduce((sum, b) => sum + b.byteSize, 0);
+    logger.info(`${targetLabel} ${leavesToTranslate.length} translatable entries, ${formatBytes(totalBytes)}, split into ${batches.length} batch(es)`);
+    for (const batch of batches) {
+        logger.info(`  Batch ${batch.index + 1}: ${batch.leaves.length} entries, ${formatBytes(batch.byteSize)}`);
+    }
+    spinner.start();
+    const result = await runBatches(batches, translator, validatedArgs.from, to, translateOptions);
+    spinner.stop();
+    let finalContent;
+    if (incrementalApplied && existingTarget !== null) {
+        finalContent = mergeTranslations(existingTarget, allLeaves, result.translations);
+    }
+    else {
+        finalContent = reconstruct(allLeaves, result.translations);
+    }
+    await writeOutput(outputPath, JSON.stringify(finalContent, null, 2));
+    return {
+        to,
+        output: outputRel,
+        fullCount: translatableLeaves.length,
+        translatedCount: result.translations.size,
+        batchCount: batches.length,
+        bytes: totalBytes,
+        calls: result.calls,
+        usage: result.usage,
+        incrementalApplied,
+    };
+}
 async function main() {
     try {
         const args = parseArgs(dntShim.Deno.args, {
-            string: ['key', 'provider', 'model', 'input', 'output', 'from', 'to', 'url'],
-            boolean: ['help', 'version'],
+            string: ['key', 'provider', 'model', 'input', 'output', 'from', 'to', 'url', 'max-batch-size', 'config'],
+            boolean: ['help', 'version', 'no-limit', 'no-timeout', 'stats', 'incremental'],
             alias: {
                 provider: 'p',
                 model: 'm',
@@ -28,75 +130,85 @@ async function main() {
                 help: 'h',
                 version: 'v',
             },
-            default: { provider: DEFAULT_PROVIDER },
         });
         const help = args.help || dntShim.Deno.args.length === 0;
         const version = args.version;
         if (version) {
-            const VERSION = denoJson.version;
-            logger.info('Glotto version: ' + VERSION);
+            logger.info('Glotto version: ' + denoJson.version);
             dntShim.Deno.exit(0);
         }
         if (help) {
+            printBanner();
             logger.box(HELP_TEXT);
             dntShim.Deno.exit(0);
         }
-        const validatedArgs = validateArgs(args);
+        printBanner();
+        const config = await loadConfig(args.config);
+        const merged = applyConfig(args, config, dntShim.Deno.args);
+        if (!merged.provider) {
+            merged.provider = DEFAULT_PROVIDER;
+        }
+        const validatedArgs = validateArgs(merged);
         const fileContent = await getImportJson(validatedArgs.input);
-        const chunks = splitJson(fileContent);
-        const totalBytes = chunks.reduce((sum, c) => sum + c.byteSize, 0);
-        const totalKeys = chunks.reduce((sum, c) => sum + c.keyCount, 0);
-        const outputPath = resolvePath(validatedArgs.output);
+        const allLeaves = extractLeaves(fileContent);
+        const translatableLeaves = allLeaves.filter((leaf) => leaf.translatable);
         logger.info('Provider: ', validatedArgs.provider);
         logger.info('Input: ', validatedArgs.input);
-        logger.info('Output: ', validatedArgs.output);
+        logger.info('Targets: ', validatedArgs.to.map((to, i) => `${to} → ${validatedArgs.output[i]}`).join(', '));
         logger.info('From: ', validatedArgs.from);
-        logger.info('To: ', validatedArgs.to);
         if (validatedArgs.model) {
             logger.info('Model: ', validatedArgs.model);
         }
         if (validatedArgs.url) {
             logger.info('URL: ', validatedArgs.url);
         }
-        logger.info(`Total: ${totalKeys} keys, ${formatBytes(totalBytes)}, split into ${chunks.length} chunk(s)`);
-        for (const chunk of chunks) {
-            logger.info(`  Chunk ${chunk.index + 1}: ${chunk.keyCount} keys, ${formatBytes(chunk.byteSize)}`);
+        if (validatedArgs.noLimit) {
+            logger.info('Rate limit protection: disabled (--no-limit)');
         }
-        spinner.start();
-        let result = '';
-        switch (validatedArgs.provider) {
-            case 'gemini': {
-                const gemini = new Gemini(validatedArgs.key, chunks, validatedArgs.from, validatedArgs.to, validatedArgs.model);
-                result = await gemini.translate();
-                break;
-            }
-            case 'openai': {
-                const openai = new OpenAIModel(validatedArgs.key, chunks, validatedArgs.from, validatedArgs.to, validatedArgs.url, validatedArgs.model);
-                result = await openai.translate();
-                break;
-            }
-            case 'anthropic': {
-                const anthropic = new AnthropicModel(validatedArgs.key, chunks, validatedArgs.from, validatedArgs.to, validatedArgs.url, validatedArgs.model);
-                result = await anthropic.translate();
-                break;
-            }
-            default: {
-                logger.warn('Provider not found');
-                break;
+        if (validatedArgs.noTimeout) {
+            logger.info('Request timeout: disabled (--no-timeout)');
+        }
+        if (validatedArgs.incremental) {
+            logger.info('Incremental mode: enabled (--incremental)');
+        }
+        if (validatedArgs.stats) {
+            logger.info('Stats: enabled (--stats)');
+        }
+        if (validatedArgs.maxBatchBytes !== DEFAULT_MAX_BATCH_BYTES) {
+            logger.info(`Max batch size: ${formatBytes(validatedArgs.maxBatchBytes)}`);
+        }
+        logger.info(`Source: ${translatableLeaves.length} translatable entries (of ${allLeaves.length} leaves)`);
+        if (translatableLeaves.length === 0 && !validatedArgs.incremental) {
+            logger.warn('No translatable entries found, copying input to output(s)');
+            for (const outputRel of validatedArgs.output) {
+                await writeOutput(resolvePath(outputRel), JSON.stringify(fileContent, null, 2));
             }
+            logger.success('Translation completed');
+            logger.info(`★ Glotto faydalı olduysa GitHub'da yıldızlamayı unutma: ${GITHUB_REPO_URL}`);
+            dntShim.Deno.exit(0);
+        }
+        const translateOptions = {
+            noLimit: validatedArgs.noLimit,
+            noTimeout: validatedArgs.noTimeout,
+        };
+        const translator = createTranslator(validatedArgs, translateOptions);
+        const perTarget = [];
+        for (let i = 0; i < validatedArgs.to.length; i++) {
+            const stat = await translateForTarget(validatedArgs, fileContent, allLeaves, validatedArgs.to[i], validatedArgs.output[i], translator, translateOptions, i, validatedArgs.to.length);
+            perTarget.push(stat);
         }
-        await writeOutput(outputPath, result);
         spinner.stop();
         logger.success('Translation completed');
+        if (validatedArgs.stats) {
+            printStats(validatedArgs, perTarget);
+        }
+        logger.info(`★ Glotto faydalı olduysa GitHub'da yıldızlamayı unutma: ${GITHUB_REPO_URL}`);
+        dntShim.Deno.exit(0);
     }
     catch (error) {
         spinner.stop();
         logger.error(error);
         dntShim.Deno.exit(1);
     }
-    finally {
-        spinner.stop();
-        dntShim.Deno.exit(0);
-    }
 }
 main();

package/esm/deno.d.ts

@@ -11,19 +11,23 @@ declare namespace _default {
         publish: string;
         "publish:npm": string;
         check: string;
+        test: string;
     };
     namespace fmt {
         let semiColons: boolean;
         let singleQuote: boolean;
         let lineWidth: number;
     }
+    namespace publish {
+        let exclude: string[];
+    }
     let imports: {
         "@anthropic-ai/sdk": string;
         "@deno/dnt": string;
         "@google/genai": string;
         "@openai/openai": string;
+        "@std/assert": string;
         "@std/cli": string;
-        "@std/encoding": string;
         "@std/path": string;
         consola: string;
     };

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "@ibodev/glotto",
-    "version": "2.9.0",
+    "version": "3.1.0",
     "exports": "./cli.ts",
     "lock": false,
     "nodeModulesDir": "auto",
@@ -10,22 +10,33 @@ export default {
         "build:npm": "deno run -A scripts/build_npm.ts",
         "publish": "deno publish",
         "publish:npm": "cd ./npm && npm publish",
-        "check": "deno check **/*.ts"
+        "check": "deno check **/*.ts",
+        "test": "deno test -A --no-check tests/"
     },
     "fmt": {
         "semiColons": true,
         "singleQuote": true,
         "lineWidth": 160
     },
+    "publish": {
+        "exclude": [
+            "tests/",
+            "scripts/",
+            "npm/",
+            "assets/",
+            "glotto.exe",
+            "CLAUDE.md"
+        ]
+    },
     "imports": {
-        "@anthropic-ai/sdk": "npm:@anthropic-ai/sdk@^0.95.0",
+        "@anthropic-ai/sdk": "npm:@anthropic-ai/sdk@^0.95.1",
         "@deno/dnt": "jsr:@deno/dnt@^0.42.3",
-        "@google/genai": "npm:@google/genai@^1.52.0",
-        "@openai/openai": "npm:openai@^6.36.0",
+        "@google/genai": "npm:@google/genai@^2.0.0",
+        "@openai/openai": "npm:openai@^6.37.0",
+        "@std/assert": "jsr:@std/assert@^1.0.19",
         "@std/cli": "jsr:@std/cli@^1.0.29",
-        "@std/encoding": "jsr:@std/encoding@^1.0.10",
         "@std/path": "jsr:@std/path@^1.1.4",
         "consola": "npm:consola@^3.4.2"
     },
-    "allowScripts": ["npm:@google/genai@1.52.0", "npm:protobufjs@7.5.6"]
+    "allowScripts": ["npm:@google/genai@1.52.0", "npm:@google/genai@2.0.0", "npm:protobufjs@7.5.6"]
 };

package/esm/src/config.d.ts

@@ -0,0 +1,4 @@
+import type { GlottoConfig, TranslateArgs } from './types.js';
+export declare function loadConfig(explicitPath?: string): Promise<GlottoConfig>;
+export declare function applyConfig(cli: TranslateArgs, config: GlottoConfig, rawArgs: string[]): TranslateArgs;
+//# sourceMappingURL=config.d.ts.map

package/esm/src/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/src/config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAuB9D,wBAAsB,UAAU,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAc7E;AAkBD,wBAAgB,WAAW,CAAC,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,aAAa,CA0CtG"}