glotto 3.0.0 → 3.1.0

package/README.md

@@ -4,30 +4,6 @@ Glotto translates i18n JSON files (i18next, react-intl, vue-i18n, etc.) using AI
 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.
 
-## Why this approach
-
-- **Provider-agnostic**: works with Gemini, OpenAI/OpenAI-compatible (Ollama, vLLM, TogetherAI, etc.) and Anthropic. Every provider implements the same
-  `TextTranslator` contract: text in, text out.
-- **No JSON deadlock**: the model is never asked to emit valid JSON, so grammar-constrained sampling, broken responses and infinite loops on local models are
-  eliminated.
-- **Structure-safe**: keys, nesting, arrays and non-string leaves (numbers, booleans, null, empty objects/arrays) are preserved by reconstruction, not by the
-  model.
-- **Token efficient**: source size per request is bounded; failed entries are retried individually instead of re-sending the whole batch.
-- **Variable preservation**: the prompt instructs the model to keep `{{name}}`, `__VAR__`, `$t(...)`, `%s`, `%d`, HTML tags and markdown intact.
-
-## How it works
-
-1. **Extract** — recursively walk the JSON and collect every leaf as `{ id, path, value, translatable }`. Empty objects/arrays are kept as non-translatable
-   leaves so the structure is rebuildable.
-2. **Batch** — group translatable leaves into batches by source byte size (`--max-batch-size`, default 12 KB).
-3. **Encode** — wrap each entry as `≪id≫value≪/id≫` and send a single prompt per batch.
-4. **Translate** — call `provider.translate(prompt) → string`. No JSON mode is requested.
-5. **Decode** — parse the response with the same tag regex, mapping `id → translation`.
-6. **Reconstruct** — walk all leaves, place translated values (or original values for non-translatable leaves) back into a fresh object/array tree following the
-   recorded path, then write the resulting JSON.
-
-If a batch response is missing some IDs, only the missing entries are retried (with exponential backoff) — the successful ones are kept.
-
 ## Installation
 
 ### [JSR (Deno)](https://jsr.io/@ibodev/glotto)
@@ -54,25 +30,43 @@ Or via npx:
 npx glotto
 ```
 
+### [pnpm](https://pnpm.io/)
+
+```bash
+pnpm add --global glotto
+```
+
+Or via pnpx:
+
+```bash
+pnpx glotto
+```
+
 ## Usage
 
-### Basic (default Gemini)
+### Basic (default OpenAI)
+
+```bash
+glotto --key <openai-api-key> -i en.json -o tr.json -f English -t Turkish
+```
+
+### Gemini
 
 ```bash
-glotto --key <gemini-api-key> -i en.json -o ar.json -f English -t Arabic
+glotto --key <gemini-api-key> -i en.json -o ar.json -f English -t Arabic -p gemini
 ```
 
-### OpenAI / OpenAI-compatible (Ollama, vLLM, etc.)
+### OpenAI / OpenAI-compatible endpoints
 
 ```bash
 glotto --key <openai-api-key> -i en.json -o tr.json -f English -t Turkish -p openai
 ```
 
-Custom base URL (e.g. local Ollama):
+Custom base URL (e.g. self-hosted OpenAI-compatible server):
 
 ```bash
-glotto --key any-string -i en.json -o tr.json -f English -t Turkish \
-  -p openai -m qwen2.5:32b --url http://localhost:11434/v1
+glotto --key <key> -i en.json -o tr.json -f English -t Turkish \
+  -p openai -m <model-name> --url <base-url>
 ```
 
 ### Anthropic (Claude)
@@ -84,7 +78,63 @@ glotto --key <anthropic-api-key> -i en.json -o tr.json -f English -t Turkish -p
 ### Override the model
 
 ```bash
-glotto --key <openai-api-key> -i en.json -o tr.json -f English -t 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>
+```
+
+### Multi-target — translate to several languages in one run
+
+Pass comma-separated values to `-t/--to` and `-o/--output`. The two lists must have the same length; entries pair up by index.
+
+```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.
+
+```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
+glotto --key <key> -i en.json -o tr.json -f English -t Turkish --stats
+```
+
+### 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
+}
+```
+
+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
@@ -107,37 +157,48 @@ glotto --key <key> -i en.json -o tr.json -f English -t Turkish --max-batch-size
 | Flag               | Description                                                                          |
 | ------------------ | ------------------------------------------------------------------------------------ |
 | `--key`            | API key for the chosen provider (required)                                           |
-| `-p`, `--provider` | `gemini` \| `openai` \| `anthropic` (default `gemini`)                               |
-| `-m`, `--model`    | Model name (defaults: `gemini-2.5-flash`, `gpt-4.1-mini`, `claude-3-5-haiku-latest`) |
+| `-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 (required)                                                          |
+| `-o`, `--output`   | Target JSON file path. Comma-separated for multi-target (required)                   |
 | `-f`, `--from`     | Source language                                                                      |
-| `-t`, `--to`       | Target 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                                                                              |
 
-## Recommended models
-
-For high-quality multilingual output via OpenAI-compatible endpoints (Ollama, vLLM):
-
-- `aya-expanse:32b` — Cohere multilingual specialist, strong Turkish/Arabic/EU languages
-- `qwen2.5:32b` / `qwen2.5:14b` — strong general multilingual + instruction-following
-- `mistral-small3:24b` — lighter, ~13 GB at q4
-- `gemma3:27b-it` — Google instruction-tuned
-
-Pure translation-only models (e.g. translategemma) are not ideal here: the prompt asks the model to preserve tags and follow per-entry instructions, which
-requires instruction-following rather than a sentence-translation fine-tune.
+## 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 -p gemini
+deno task cli --key <key> -i en.json -o tr.json -f English -t Turkish
 ```
 
 Build a single-file binary:
@@ -152,6 +213,10 @@ Build npm package:
 deno task build:npm
 ```
 
+## Star us
+
+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 © 2026

package/esm/cli.js

@@ -3,9 +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, writeOutput } from './src/file.js';
+import { getImportJson, readJsonIfExists, resolvePath, writeOutput } from './src/file.js';
 import { extractLeaves, groupIntoBatches, reconstruct, runBatches } from './src/translator.js';
-import { DEFAULT_MAX_BATCH_BYTES, DEFAULT_PROVIDER, HELP_TEXT } from './src/contants.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';
@@ -13,7 +15,7 @@ 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' });
-const createTranslator = (args, options) => {
+function createTranslator(args, options) {
     switch (args.provider) {
         case 'gemini':
             return new Gemini(args.key, args.model, options);
@@ -24,12 +26,99 @@ const createTranslator = (args, 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', 'max-batch-size'],
-            boolean: ['help', 'version', 'no-limit', 'no-timeout'],
+            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',
@@ -41,7 +130,6 @@ async function main() {
                 help: 'h',
                 version: 'v',
             },
-            default: { provider: DEFAULT_PROVIDER },
         });
         const help = args.help || dntShim.Deno.args.length === 0;
         const version = args.version;
@@ -50,38 +138,53 @@ async function main() {
             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 allLeaves = extractLeaves(fileContent);
         const translatableLeaves = allLeaves.filter((leaf) => leaf.translatable);
-        const batches = groupIntoBatches(allLeaves, validatedArgs.maxBatchBytes);
-        const totalBytes = batches.reduce((sum, b) => sum + b.byteSize, 0);
         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)
+        if (validatedArgs.model) {
             logger.info('Model: ', validatedArgs.model);
-        if (validatedArgs.url)
+        }
+        if (validatedArgs.url) {
             logger.info('URL: ', validatedArgs.url);
-        if (validatedArgs.noLimit)
+        }
+        if (validatedArgs.noLimit) {
             logger.info('Rate limit protection: disabled (--no-limit)');
-        if (validatedArgs.noTimeout)
+        }
+        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(`Total: ${translatableLeaves.length} translatable entries (of ${allLeaves.length} leaves), ${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)}`);
-        }
-        if (batches.length === 0) {
-            logger.warn('No translatable entries found, copying input to output');
-            await writeOutput(resolvePath(validatedArgs.output), JSON.stringify(fileContent, null, 2));
+        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 = {
@@ -89,22 +192,23 @@ async function main() {
             noTimeout: validatedArgs.noTimeout,
         };
         const translator = createTranslator(validatedArgs, translateOptions);
-        spinner.start();
-        const translations = await runBatches(batches, translator, validatedArgs.from, validatedArgs.to, translateOptions);
-        const result = reconstruct(allLeaves, translations);
-        const outputPath = resolvePath(validatedArgs.output);
-        await writeOutput(outputPath, JSON.stringify(result, null, 2));
+        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);
+        }
         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,17 +11,22 @@ 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/path": string;
         consola: string;

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "@ibodev/glotto",
-    "version": "3.0.0",
+    "version": "3.1.0",
     "exports": "./cli.ts",
     "lock": false,
     "nodeModulesDir": "auto",
@@ -10,21 +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/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"}

package/esm/src/config.js

@@ -0,0 +1,95 @@
+import * as dntShim from "../_dnt.shims.js";
+import { join } from '../deps/jsr.io/@std/path/1.1.4/mod.js';
+import { CONFIG_FILE_NAME } from './contants.js';
+async function readConfigFile(path) {
+    let raw;
+    try {
+        raw = await dntShim.Deno.readTextFile(path);
+    }
+    catch (error) {
+        if (error instanceof dntShim.Deno.errors.NotFound) {
+            return null;
+        }
+        throw error;
+    }
+    if (raw.trim() === '') {
+        return {};
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`Config file must contain a JSON object: ${path}`);
+    }
+    return parsed;
+}
+export async function loadConfig(explicitPath) {
+    if (explicitPath) {
+        const config = await readConfigFile(explicitPath);
+        if (config === null) {
+            throw new Error(`Config file not found: ${explicitPath}`);
+        }
+        return config;
+    }
+    const defaultPath = join(dntShim.Deno.cwd(), CONFIG_FILE_NAME);
+    const config = await readConfigFile(defaultPath);
+    if (config === null) {
+        return {};
+    }
+    return config;
+}
+function joinList(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        return value.join(',');
+    }
+    return value;
+}
+function rawArgsHas(rawArgs, flag) {
+    const long = `--${flag}`;
+    const longEq = `--${flag}=`;
+    return rawArgs.some((a) => a === long || a.startsWith(longEq));
+}
+export function applyConfig(cli, config, rawArgs) {
+    const merged = { ...cli };
+    if (merged.key === undefined && config.key !== undefined) {
+        merged.key = config.key;
+    }
+    if (merged.provider === undefined && config.provider !== undefined) {
+        merged.provider = config.provider;
+    }
+    if (merged.model === undefined && config.model !== undefined) {
+        merged.model = config.model;
+    }
+    if (merged.input === undefined && config.input !== undefined) {
+        merged.input = config.input;
+    }
+    if (merged.output === undefined && config.output !== undefined) {
+        merged.output = joinList(config.output);
+    }
+    if (merged.from === undefined && config.from !== undefined) {
+        merged.from = config.from;
+    }
+    if (merged.to === undefined && config.to !== undefined) {
+        merged.to = joinList(config.to);
+    }
+    if (merged.url === undefined && config.url !== undefined) {
+        merged.url = config.url;
+    }
+    if (merged['max-batch-size'] === undefined && config.maxBatchSize !== undefined) {
+        merged['max-batch-size'] = String(config.maxBatchSize);
+    }
+    if (!rawArgsHas(rawArgs, 'no-limit') && config.noLimit !== undefined) {
+        merged['no-limit'] = config.noLimit;
+    }
+    if (!rawArgsHas(rawArgs, 'no-timeout') && config.noTimeout !== undefined) {
+        merged['no-timeout'] = config.noTimeout;
+    }
+    if (!rawArgsHas(rawArgs, 'stats') && config.stats !== undefined) {
+        merged.stats = config.stats;
+    }
+    if (!rawArgsHas(rawArgs, 'incremental') && config.incremental !== undefined) {
+        merged.incremental = config.incremental;
+    }
+    return merged;
+}

package/esm/src/contants.d.ts

@@ -5,5 +5,9 @@ export declare const DEFAULT_MAX_BATCH_BYTES: 12000;
 export declare const MAX_RETRIES: 3;
 export declare const BASE_RETRY_DELAY_MS: 2000;
 export declare const INTER_BATCH_DELAY_MS: 1500;
+export declare const INTER_LEAF_DELAY_MS: 200;
+export declare const PER_LEAF_FALLBACK_RATIO: 0.5;
+export declare const GITHUB_REPO_URL: "https://github.com/ibodev1/glotto";
+export declare const CONFIG_FILE_NAME: "glotto.config.json";
 export declare const HELP_TEXT: string;
 //# sourceMappingURL=contants.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"contants.d.ts","sourceRoot":"","sources":["../../src/src/contants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,gBAAgB,EAAE,QAAmB,CAAC;AAEnD,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAInD,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAG,KAAe,CAAC;AAEvD,eAAO,MAAM,WAAW,EAAG,CAAU,CAAC;AAEtC,eAAO,MAAM,mBAAmB,EAAG,IAAc,CAAC;AAElD,eAAO,MAAM,oBAAoB,EAAG,IAAc,CAAC;AAEnD,eAAO,MAAM,SAAS,QAgCrB,CAAC"}
+{"version":3,"file":"contants.d.ts","sourceRoot":"","sources":["../../src/src/contants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,gBAAgB,EAAE,QAAmB,CAAC;AAEnD,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAInD,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAG,KAAe,CAAC;AAEvD,eAAO,MAAM,WAAW,EAAG,CAAU,CAAC;AAEtC,eAAO,MAAM,mBAAmB,EAAG,IAAc,CAAC;AAElD,eAAO,MAAM,oBAAoB,EAAG,IAAc,CAAC;AAEnD,eAAO,MAAM,mBAAmB,EAAG,GAAY,CAAC;AAEhD,eAAO,MAAM,uBAAuB,EAAG,GAAY,CAAC;AAEpD,eAAO,MAAM,eAAe,EAAG,mCAA4C,CAAC;AAE5E,eAAO,MAAM,gBAAgB,EAAG,oBAA6B,CAAC;AAE9D,eAAO,MAAM,SAAS,QAqCrB,CAAC"}