glotto 2.9.0 → 3.0.0

package/README.md

@@ -1,32 +1,42 @@
 # 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.
+
+## 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
 
-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,19 +44,11 @@ deno run -A jsr:@ibodev/glotto
 
 ### [npm (Node)](https://www.npmjs.com/package/glotto)
 
-#### Global Installation
-
-Install Glotto globally via npm to use it as a CLI tool:
-
 ```bash
 npm install --global glotto
 ```
 
-After installation, the `glotto` command will be available in your terminal.
-
-#### Direct Execution
-
-Run Glotto directly using npx without installation:
+Or via npx:
 
 ```bash
 npx glotto
@@ -54,73 +56,102 @@ npx glotto
 
 ## Usage
 
-### Basic usage (default Gemini)
+### Basic (default Gemini)
 
 ```bash
 glotto --key <gemini-api-key> -i en.json -o ar.json -f English -t Arabic
 ```
 
-### Use OpenAI instead of Gemini
+### OpenAI / OpenAI-compatible (Ollama, vLLM, etc.)
+
+```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):
 
 ```bash
-glotto --key <openai-api-key> --input=en.json --output=tr.json --from=English --to=Turkish -p openai
+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
 ```
 
-Optional custom OpenAI base URL:
+### Anthropic (Claude)
 
 ```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 <anthropic-api-key> -i en.json -o tr.json -f English -t Turkish -p anthropic
 ```
 
-### Use Anthropic (Claude)
+### Override the model
 
 ```bash
-glotto --key <anthropic-api-key> --input=en.json --output=tr.json --from=English --to=Turkish -p anthropic
+glotto --key <openai-api-key> -i en.json -o tr.json -f English -t Turkish -p openai -m gpt-4.1
 ```
 
-Optional custom Anthropic base URL:
+### Disable rate-limit delay and request timeout
 
 ```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 <key> -i en.json -o tr.json -f English -t Turkish --no-limit --no-timeout
 ```
 
-Override default model for a provider:
+### 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 <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 --max-batch-size 8
 ```
 
-### Parameters
+## Parameters
+
+| 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`) |
+| `-i`, `--input`    | Source JSON file (required)                                                          |
+| `-o`, `--output`   | Target JSON file (required)                                                          |
+| `-f`, `--from`     | Source language                                                                      |
+| `-t`, `--to`       | Target language                                                                      |
+| `--url`            | Custom base URL for OpenAI/Anthropic                                                 |
+| `--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
 
-- `--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)
+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.
 
 ## Development
 
-To run the project in development mode:
+Run from source:
 
 ```bash
-deno task cli --key <gemini-or-openai-api-key> --input=en.json --output=tr.json --from=English --to=Turkish -p gemini
+deno task cli --key <key> -i en.json -o tr.json -f English -t Turkish -p gemini
 ```
 
-### Building the Project
-
-To create a production build:
+Build a single-file binary:
 
 ```bash
 deno task build
 ```
 
-## Contributing
+Build npm package:
 
-Contributions are welcome! Feel free to submit issues and pull requests.
+```bash
+deno task build:npm
+```
 
 ## License
 
-MIT Licence @ 2026
+MIT © 2026

package/esm/cli.js

@@ -3,8 +3,9 @@ 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, 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 { formatBytes, validateArgs } from './src/utilites.js';
 import { logger } from './src/logger.js';
 import denoJson from './deno.js';
@@ -12,11 +13,23 @@ 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) => {
+    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}`);
+    }
+};
 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'],
+            boolean: ['help', 'version', 'no-limit', 'no-timeout'],
             alias: {
                 provider: 'p',
                 model: 'm',
@@ -33,8 +46,7 @@ async function main() {
         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) {
@@ -43,49 +55,45 @@ async function main() {
         }
         const validatedArgs = validateArgs(args);
         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);
+        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('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)
+            logger.info('Rate limit protection: disabled (--no-limit)');
+        if (validatedArgs.noTimeout)
+            logger.info('Request timeout: disabled (--no-timeout)');
+        if (validatedArgs.maxBatchBytes !== DEFAULT_MAX_BATCH_BYTES) {
+            logger.info(`Max batch size: ${formatBytes(validatedArgs.maxBatchBytes)}`);
         }
-        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)}`);
+        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)}`);
         }
-        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 (batches.length === 0) {
+            logger.warn('No translatable entries found, copying input to output');
+            await writeOutput(resolvePath(validatedArgs.output), JSON.stringify(fileContent, null, 2));
+            dntShim.Deno.exit(0);
         }
-        await writeOutput(outputPath, result);
+        const translateOptions = {
+            noLimit: validatedArgs.noLimit,
+            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));
         spinner.stop();
         logger.success('Translation completed');
     }

package/esm/deno.d.ts

@@ -23,7 +23,6 @@ declare namespace _default {
         "@google/genai": string;
         "@openai/openai": 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.0.0",
     "exports": "./cli.ts",
     "lock": false,
     "nodeModulesDir": "auto",
@@ -23,7 +23,6 @@ export default {
         "@google/genai": "npm:@google/genai@^1.52.0",
         "@openai/openai": "npm:openai@^6.36.0",
         "@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"
     },

package/esm/src/contants.d.ts

@@ -1,9 +1,9 @@
 import type { Provider } from './types.js';
 export declare const DEFAULT_PROVIDER: Provider;
 export declare const DEFAULT_MODELS: Record<Provider, string>;
-export declare const DEFAULT_MAX_CHUNK_BYTES: 30000;
+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_CHUNK_DELAY_MS: 1500;
+export declare const INTER_BATCH_DELAY_MS: 1500;
 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,QAsBrB,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,SAAS,QAgCrB,CAAC"}

package/esm/src/contants.js

@@ -4,30 +4,40 @@ export const DEFAULT_MODELS = {
     openai: 'gpt-4.1-mini',
     anthropic: 'claude-3-5-haiku-latest',
 };
-export const DEFAULT_MAX_CHUNK_BYTES = 30_000;
+export const DEFAULT_MAX_BATCH_BYTES = 12_000;
 export const MAX_RETRIES = 3;
 export const BASE_RETRY_DELAY_MS = 2_000;
-export const INTER_CHUNK_DELAY_MS = 1_500;
+export const INTER_BATCH_DELAY_MS = 1_500;
 export const HELP_TEXT = `
 Glotto AI Translator
 -------------------
 A tool for translating i18n JSON files using AI services.
 
+Glotto walks the input JSON, extracts every string leaf with its path, sends them to the
+chosen provider as plain-text batches (using ≪id≫value≪/id≫ tagged entries), and
+reconstructs the JSON from the responses. JSON structure, keys, variables and HTML tags
+are preserved by the tool itself — the model only sees and produces text.
+
 Options:
-  --key          API key for the AI service (required)
-  -p, --provider AI translation provider to use (default: ${DEFAULT_PROVIDER})
-  -m, --model    Model name for the selected provider (optional)
-  -i, --input    Path to source JSON file (required)
-  -o, --output   Path to target JSON file (required)
-  -f, --from     Source language (required)
-  -t, --to       Target language (required)
-  --url          Custom base URL for OpenAI/Anthropic (optional)
-  -h, --help     Display this help message
-  -v, --version  Display version
+  --key               API key for the AI service (required)
+  -p, --provider      AI translation provider to use (default: ${DEFAULT_PROVIDER})
+  -m, --model         Model name for the selected provider (optional)
+  -i, --input         Path to source JSON file (required)
+  -o, --output        Path to target JSON file (required)
+  -f, --from          Source language (required)
+  -t, --to            Target language (required)
+  --url               Custom base URL for OpenAI/Anthropic (optional)
+  --no-limit          Disable rate limit delay between batches
+  --no-timeout        Disable request timeout (wait indefinitely for AI response)
+  --max-batch-size    Maximum source size per batch, in KB (default: ${DEFAULT_MAX_BATCH_BYTES / 1024} KB)
+  -h, --help          Display this help message
+  -v, --version       Display version
 
 Examples:
   glotto --key {{key}} --input=en.json --output=tr.json --from=english --to=turkish
   glotto --key {{key}} -i en.json -o tr.json -f english -t turkish -p gemini
   glotto --key {{key}} -i en.json -o tr.json -f english -t turkish -p openai
   glotto --key {{key}} -i en.json -o tr.json -f english -t turkish -p anthropic
+  glotto --key {{key}} -i en.json -o tr.json -f english -t turkish --no-limit --no-timeout
+  glotto --key {{key}} -i en.json -o tr.json -f english -t turkish --max-batch-size 8
 `;

package/esm/src/file.d.ts

@@ -1,10 +1,5 @@
-import type { ChunkInfo, JsonObject } from './types.js';
+import type { JsonValue } from './types.js';
 export declare const resolvePath: (...paths: string[]) => string;
-export declare const getImportJson: <T = JsonObject>(input: string) => Promise<T>;
+export declare const getImportJson: <T = JsonValue>(input: string) => Promise<T>;
 export declare const writeOutput: (outputPath: string, content: string) => Promise<void>;
-export declare const existsFile: (path: string) => Promise<boolean>;
-export declare const ensureDirectoryExists: (directory: string) => Promise<void>;
-export declare const splitJson: (data: JsonObject, maxChunkBytes?: number) => ChunkInfo[];
-export declare const mergeInputs: (inputs: JsonObject[]) => JsonObject;
-export declare const writeTemp: (targetLanguage: string, tempJsonFileName: string, content: string) => Promise<void>;
 //# sourceMappingURL=file.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/src/file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGxD,eAAO,MAAM,WAAW,GAAI,GAAG,OAAO,MAAM,EAAE,WAE7C,CAAC;AAEF,eAAO,MAAM,aAAa,GAAU,CAAC,GAAG,UAAU,EAAE,OAAO,MAAM,KAAG,OAAO,CAAC,CAAC,CAS5E,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,YAAY,MAAM,EAAE,SAAS,MAAM,kBAEpE,CAAC;AAEF,eAAO,MAAM,UAAU,GAAU,MAAM,MAAM,qBAW5C,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAU,WAAW,MAAM,KAAG,OAAO,CAAC,IAAI,CAK3E,CAAC;AAeF,eAAO,MAAM,SAAS,GAAI,MAAM,UAAU,EAAE,gBAAe,MAAe,KAAG,SAAS,EA4DrF,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,QAAQ,UAAU,EAAE,KAAG,UAElD,CAAC;AAkBF,eAAO,MAAM,SAAS,GAAU,gBAAgB,MAAM,EAAE,kBAAkB,MAAM,EAAE,SAAS,MAAM,kBAKhG,CAAC"}
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/src/file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,eAAO,MAAM,WAAW,GAAI,GAAG,OAAO,MAAM,EAAE,KAAG,MAA4C,CAAC;AAE9F,eAAO,MAAM,aAAa,GAAU,CAAC,GAAG,SAAS,EAAE,OAAO,MAAM,KAAG,OAAO,CAAC,CAAC,CAO3E,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,YAAY,MAAM,EAAE,SAAS,MAAM,KAAG,OAAO,CAAC,IAAI,CAEnF,CAAC"}

package/esm/src/file.js

@@ -1,9 +1,6 @@
 import * as dntShim from "../_dnt.shims.js";
 import { join } from '../deps/jsr.io/@std/path/1.1.4/mod.js';
-import { logger } from './logger.js';
-export const resolvePath = (...paths) => {
-    return join(dntShim.Deno.cwd(), ...paths);
-};
+export const resolvePath = (...paths) => join(dntShim.Deno.cwd(), ...paths);
 export const getImportJson = async (input) => {
     const filePath = resolvePath(input);
     const fileContent = await dntShim.Deno.readTextFile(filePath);
@@ -15,107 +12,3 @@ export const getImportJson = async (input) => {
 export const writeOutput = async (outputPath, content) => {
     await dntShim.Deno.writeTextFile(outputPath, content, { create: true });
 };
-export const existsFile = async (path) => {
-    try {
-        await dntShim.Deno.stat(path);
-        return true;
-    }
-    catch (error) {
-        if (error instanceof dntShim.Deno.errors.NotFound) {
-            return false;
-        }
-        throw error;
-    }
-};
-export const ensureDirectoryExists = async (directory) => {
-    const directoryExists = await existsFile(directory);
-    if (!directoryExists) {
-        await dntShim.Deno.mkdir(directory, { recursive: true });
-    }
-};
-const getByteSize = (str) => {
-    return new TextEncoder().encode(str).byteLength;
-};
-const buildChunkWithSize = (data, keys) => {
-    const chunk = Object.create(null);
-    for (const key of keys) {
-        chunk[key] = data[key];
-    }
-    const json = JSON.stringify(chunk);
-    return { json, size: getByteSize(json) };
-};
-export const splitJson = (data, maxChunkBytes = 30_000) => {
-    const encoder = new TextEncoder();
-    const dataKeys = Object.keys(data);
-    const totalKeys = dataKeys.length;
-    const fullJson = JSON.stringify(data);
-    const totalBytes = getByteSize(fullJson);
-    if (totalBytes <= maxChunkBytes) {
-        return [
-            {
-                data: encoder.encode(fullJson),
-                keyCount: totalKeys,
-                byteSize: totalBytes,
-                index: 0,
-            },
-        ];
-    }
-    const chunks = [];
-    let currentKeys = [];
-    let currentSize = 2;
-    for (let i = 0; i < totalKeys; i++) {
-        const key = dataKeys[i];
-        const keyValueJson = JSON.stringify({ [key]: data[key] });
-        const entrySize = getByteSize(keyValueJson) - 2;
-        const separatorSize = currentKeys.length > 0 ? 1 : 0;
-        const projectedSize = currentSize + entrySize + separatorSize;
-        if (projectedSize > maxChunkBytes && currentKeys.length > 0) {
-            const { json, size } = buildChunkWithSize(data, currentKeys);
-            chunks.push({
-                data: encoder.encode(json),
-                keyCount: currentKeys.length,
-                byteSize: size,
-                index: chunks.length,
-            });
-            currentKeys = [key];
-            currentSize = 2 + entrySize;
-        }
-        else {
-            currentKeys.push(key);
-            currentSize = projectedSize;
-        }
-    }
-    if (currentKeys.length > 0) {
-        const { json, size } = buildChunkWithSize(data, currentKeys);
-        chunks.push({
-            data: encoder.encode(json),
-            keyCount: currentKeys.length,
-            byteSize: size,
-            index: chunks.length,
-        });
-    }
-    return chunks;
-};
-export const mergeInputs = (inputs) => {
-    return Object.assign({}, ...inputs);
-};
-const getOsTempDir = () => {
-    if (dntShim.Deno.build.os === 'windows') {
-        return dntShim.Deno.env.get('TEMP') ?? dntShim.Deno.env.get('TMP') ?? 'C:\\Windows\\Temp';
-    }
-    return dntShim.Deno.env.get('TMPDIR') ?? '/tmp';
-};
-const resolveTempDir = async (targetLanguage) => {
-    const tempDir = getOsTempDir();
-    const glottoTempDir = join(tempDir, 'glotto');
-    await ensureDirectoryExists(glottoTempDir);
-    const languageTempDir = join(glottoTempDir, targetLanguage);
-    await ensureDirectoryExists(languageTempDir);
-    return languageTempDir;
-};
-export const writeTemp = async (targetLanguage, tempJsonFileName, content) => {
-    const tempDir = await resolveTempDir(targetLanguage);
-    const tempJsonFilePath = join(tempDir, tempJsonFileName);
-    await dntShim.Deno.writeTextFile(tempJsonFilePath, content, { create: true });
-    logger.info(`Temp saved: ${tempJsonFilePath}`);
-};

package/esm/src/providers/anthropic.d.ts

@@ -1,14 +1,9 @@
-import Anthropic from '@anthropic-ai/sdk';
-import type { ChunkInfo, Translatable } from '../types.js';
-declare class AnthropicModel implements Translatable {
-    chunks: ChunkInfo[];
-    from: string;
-    to: string;
-    client: Anthropic;
-    model: string;
-    constructor(key: string, chunks: ChunkInfo[], from: string, to: string, baseUrl?: string, modelName?: string);
-    private translateChunk;
-    translate(): Promise<string>;
+import type { TextTranslator, TranslateOptions } from '../types.js';
+declare class AnthropicModel implements TextTranslator {
+    private client;
+    private model;
+    constructor(key: string, baseUrl?: string, modelName?: string, options?: TranslateOptions);
+    translate(prompt: string): Promise<string>;
 }
 export default AnthropicModel;
 //# sourceMappingURL=anthropic.d.ts.map

package/esm/src/providers/anthropic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../src/src/providers/anthropic.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAc,YAAY,EAAE,MAAM,aAAa,CAAC;AAQvE,cAAM,cAAe,YAAW,YAAY;IAC1C,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,SAAS,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;gBAEF,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;YAW9F,cAAc;IAkEtB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;CAqCnC;AAED,eAAe,cAAc,CAAC"}
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../src/src/providers/anthropic.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpE,cAAM,cAAe,YAAW,cAAc;IAC5C,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,KAAK,CAAS;gBAGpB,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,EAClB,OAAO,GAAE,gBAAuD;IAU5D,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAYjD;AAED,eAAe,cAAc,CAAC"}