glotto 2.9.0 → 3.1.0

package/script/cli.js

@@ -42,6 +42,9 @@ const dntShim = __importStar(require("./_dnt.shims.js"));
 const unstable_spinner_js_1 = require("./deps/jsr.io/@std/cli/1.0.29/unstable_spinner.js");
 const mod_js_1 = require("./deps/jsr.io/@std/cli/1.0.29/mod.js");
 const file_js_1 = require("./src/file.js");
+const translator_js_1 = require("./src/translator.js");
+const diff_js_1 = require("./src/diff.js");
+const config_js_1 = require("./src/config.js");
 const contants_js_1 = require("./src/contants.js");
 const utilites_js_1 = require("./src/utilites.js");
 const logger_js_1 = require("./src/logger.js");
@@ -50,11 +53,110 @@ const gemini_js_1 = __importDefault(require("./src/providers/gemini.js"));
 const openai_js_1 = __importDefault(require("./src/providers/openai.js"));
 const anthropic_js_1 = __importDefault(require("./src/providers/anthropic.js"));
 const spinner = new unstable_spinner_js_1.Spinner({ message: 'AI Thinks...', color: 'cyan' });
+function createTranslator(args, options) {
+    switch (args.provider) {
+        case 'gemini':
+            return new gemini_js_1.default(args.key, args.model, options);
+        case 'openai':
+            return new openai_js_1.default(args.key, args.url, args.model, options);
+        case 'anthropic':
+            return new anthropic_js_1.default(args.key, args.url, args.model, options);
+        default:
+            throw new Error(`Unknown provider: ${args.provider}`);
+    }
+}
+function printBanner() {
+    logger_js_1.logger.box(`Glotto AI Translator v${deno_js_1.default.version}\n${contants_js_1.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), ${(0, utilites_js_1.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), ${(0, utilites_js_1.formatBytes)(totalBytes)}`);
+    lines.push(`Total tokens — in: ${totalInput}, out: ${totalOutput}, sum: ${totalInput + totalOutput}`);
+    logger_js_1.logger.box(lines.join('\n'));
+}
+async function translateForTarget(validatedArgs, fileContent, allLeaves, to, outputRel, translator, translateOptions, targetIndex, totalTargets) {
+    const outputPath = (0, file_js_1.resolvePath)(outputRel);
+    const targetLabel = `[Target ${targetIndex + 1}/${totalTargets}: ${to}]`;
+    logger_js_1.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 (0, file_js_1.readJsonIfExists)(outputPath);
+        if (existingTarget !== null) {
+            leavesToTranslate = (0, diff_js_1.findMissingLeaves)(allLeaves, existingTarget);
+            incrementalApplied = true;
+            logger_js_1.logger.info(`${targetLabel} Incremental: ${leavesToTranslate.length}/${translatableLeaves.length} entries missing in existing target`);
+        }
+        else {
+            logger_js_1.logger.info(`${targetLabel} Incremental: target file not found, doing full translation`);
+        }
+    }
+    if (leavesToTranslate.length === 0) {
+        logger_js_1.logger.info(`${targetLabel} Nothing to translate, writing existing/source content`);
+        const content = existingTarget !== null ? existingTarget : fileContent;
+        await (0, file_js_1.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 = (0, translator_js_1.groupIntoBatches)(leavesToTranslate, validatedArgs.maxBatchBytes);
+    const totalBytes = batches.reduce((sum, b) => sum + b.byteSize, 0);
+    logger_js_1.logger.info(`${targetLabel} ${leavesToTranslate.length} translatable entries, ${(0, utilites_js_1.formatBytes)(totalBytes)}, split into ${batches.length} batch(es)`);
+    for (const batch of batches) {
+        logger_js_1.logger.info(`  Batch ${batch.index + 1}: ${batch.leaves.length} entries, ${(0, utilites_js_1.formatBytes)(batch.byteSize)}`);
+    }
+    spinner.start();
+    const result = await (0, translator_js_1.runBatches)(batches, translator, validatedArgs.from, to, translateOptions);
+    spinner.stop();
+    let finalContent;
+    if (incrementalApplied && existingTarget !== null) {
+        finalContent = (0, diff_js_1.mergeTranslations)(existingTarget, allLeaves, result.translations);
+    }
+    else {
+        finalContent = (0, translator_js_1.reconstruct)(allLeaves, result.translations);
+    }
+    await (0, file_js_1.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 = (0, mod_js_1.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',
@@ -66,75 +168,85 @@ async function main() {
                 help: 'h',
                 version: 'v',
             },
-            default: { provider: contants_js_1.DEFAULT_PROVIDER },
         });
         const help = args.help || dntShim.Deno.args.length === 0;
         const version = args.version;
         if (version) {
-            const VERSION = deno_js_1.default.version;
-            logger_js_1.logger.info('Glotto version: ' + VERSION);
+            logger_js_1.logger.info('Glotto version: ' + deno_js_1.default.version);
             dntShim.Deno.exit(0);
         }
         if (help) {
+            printBanner();
             logger_js_1.logger.box(contants_js_1.HELP_TEXT);
             dntShim.Deno.exit(0);
         }
-        const validatedArgs = (0, utilites_js_1.validateArgs)(args);
+        printBanner();
+        const config = await (0, config_js_1.loadConfig)(args.config);
+        const merged = (0, config_js_1.applyConfig)(args, config, dntShim.Deno.args);
+        if (!merged.provider) {
+            merged.provider = contants_js_1.DEFAULT_PROVIDER;
+        }
+        const validatedArgs = (0, utilites_js_1.validateArgs)(merged);
         const fileContent = await (0, file_js_1.getImportJson)(validatedArgs.input);
-        const chunks = (0, file_js_1.splitJson)(fileContent);
-        const totalBytes = chunks.reduce((sum, c) => sum + c.byteSize, 0);
-        const totalKeys = chunks.reduce((sum, c) => sum + c.keyCount, 0);
-        const outputPath = (0, file_js_1.resolvePath)(validatedArgs.output);
+        const allLeaves = (0, translator_js_1.extractLeaves)(fileContent);
+        const translatableLeaves = allLeaves.filter((leaf) => leaf.translatable);
         logger_js_1.logger.info('Provider: ', validatedArgs.provider);
         logger_js_1.logger.info('Input: ', validatedArgs.input);
-        logger_js_1.logger.info('Output: ', validatedArgs.output);
+        logger_js_1.logger.info('Targets: ', validatedArgs.to.map((to, i) => `${to} → ${validatedArgs.output[i]}`).join(', '));
         logger_js_1.logger.info('From: ', validatedArgs.from);
-        logger_js_1.logger.info('To: ', validatedArgs.to);
         if (validatedArgs.model) {
             logger_js_1.logger.info('Model: ', validatedArgs.model);
         }
         if (validatedArgs.url) {
             logger_js_1.logger.info('URL: ', validatedArgs.url);
         }
-        logger_js_1.logger.info(`Total: ${totalKeys} keys, ${(0, utilites_js_1.formatBytes)(totalBytes)}, split into ${chunks.length} chunk(s)`);
-        for (const chunk of chunks) {
-            logger_js_1.logger.info(`  Chunk ${chunk.index + 1}: ${chunk.keyCount} keys, ${(0, utilites_js_1.formatBytes)(chunk.byteSize)}`);
+        if (validatedArgs.noLimit) {
+            logger_js_1.logger.info('Rate limit protection: disabled (--no-limit)');
         }
-        spinner.start();
-        let result = '';
-        switch (validatedArgs.provider) {
-            case 'gemini': {
-                const gemini = new gemini_js_1.default(validatedArgs.key, chunks, validatedArgs.from, validatedArgs.to, validatedArgs.model);
-                result = await gemini.translate();
-                break;
-            }
-            case 'openai': {
-                const openai = new openai_js_1.default(validatedArgs.key, chunks, validatedArgs.from, validatedArgs.to, validatedArgs.url, validatedArgs.model);
-                result = await openai.translate();
-                break;
-            }
-            case 'anthropic': {
-                const anthropic = new anthropic_js_1.default(validatedArgs.key, chunks, validatedArgs.from, validatedArgs.to, validatedArgs.url, validatedArgs.model);
-                result = await anthropic.translate();
-                break;
-            }
-            default: {
-                logger_js_1.logger.warn('Provider not found');
-                break;
+        if (validatedArgs.noTimeout) {
+            logger_js_1.logger.info('Request timeout: disabled (--no-timeout)');
+        }
+        if (validatedArgs.incremental) {
+            logger_js_1.logger.info('Incremental mode: enabled (--incremental)');
+        }
+        if (validatedArgs.stats) {
+            logger_js_1.logger.info('Stats: enabled (--stats)');
+        }
+        if (validatedArgs.maxBatchBytes !== contants_js_1.DEFAULT_MAX_BATCH_BYTES) {
+            logger_js_1.logger.info(`Max batch size: ${(0, utilites_js_1.formatBytes)(validatedArgs.maxBatchBytes)}`);
+        }
+        logger_js_1.logger.info(`Source: ${translatableLeaves.length} translatable entries (of ${allLeaves.length} leaves)`);
+        if (translatableLeaves.length === 0 && !validatedArgs.incremental) {
+            logger_js_1.logger.warn('No translatable entries found, copying input to output(s)');
+            for (const outputRel of validatedArgs.output) {
+                await (0, file_js_1.writeOutput)((0, file_js_1.resolvePath)(outputRel), JSON.stringify(fileContent, null, 2));
             }
+            logger_js_1.logger.success('Translation completed');
+            logger_js_1.logger.info(`★ Glotto faydalı olduysa GitHub'da yıldızlamayı unutma: ${contants_js_1.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 (0, file_js_1.writeOutput)(outputPath, result);
         spinner.stop();
         logger_js_1.logger.success('Translation completed');
+        if (validatedArgs.stats) {
+            printStats(validatedArgs, perTarget);
+        }
+        logger_js_1.logger.info(`★ Glotto faydalı olduysa GitHub'da yıldızlamayı unutma: ${contants_js_1.GITHUB_REPO_URL}`);
+        dntShim.Deno.exit(0);
     }
     catch (error) {
         spinner.stop();
         logger_js_1.logger.error(error);
         dntShim.Deno.exit(1);
     }
-    finally {
-        spinner.stop();
-        dntShim.Deno.exit(0);
-    }
 }
 main();

package/script/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/script/deno.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     "name": "@ibodev/glotto",
-    "version": "2.9.0",
+    "version": "3.1.0",
     "exports": "./cli.ts",
     "lock": false,
     "nodeModulesDir": "auto",
@@ -12,22 +12,33 @@ exports.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/script/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/script/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/script/src/config.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.applyConfig = applyConfig;
+const dntShim = __importStar(require("../_dnt.shims.js"));
+const mod_js_1 = require("../deps/jsr.io/@std/path/1.1.4/mod.js");
+const contants_js_1 = require("./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;
+}
+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 = (0, mod_js_1.join)(dntShim.Deno.cwd(), contants_js_1.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));
+}
+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/script/src/contants.d.ts

@@ -1,9 +1,13 @@
 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 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/script/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,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"}

package/script/src/contants.js

@@ -1,36 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HELP_TEXT = exports.INTER_CHUNK_DELAY_MS = exports.BASE_RETRY_DELAY_MS = exports.MAX_RETRIES = exports.DEFAULT_MAX_CHUNK_BYTES = exports.DEFAULT_MODELS = exports.DEFAULT_PROVIDER = void 0;
-exports.DEFAULT_PROVIDER = 'gemini';
+exports.HELP_TEXT = exports.CONFIG_FILE_NAME = exports.GITHUB_REPO_URL = exports.PER_LEAF_FALLBACK_RATIO = exports.INTER_LEAF_DELAY_MS = exports.INTER_BATCH_DELAY_MS = exports.BASE_RETRY_DELAY_MS = exports.MAX_RETRIES = exports.DEFAULT_MAX_BATCH_BYTES = exports.DEFAULT_MODELS = exports.DEFAULT_PROVIDER = void 0;
+exports.DEFAULT_PROVIDER = 'openai';
 exports.DEFAULT_MODELS = {
     gemini: 'gemini-2.5-flash',
     openai: 'gpt-4.1-mini',
     anthropic: 'claude-3-5-haiku-latest',
 };
-exports.DEFAULT_MAX_CHUNK_BYTES = 30_000;
+exports.DEFAULT_MAX_BATCH_BYTES = 12_000;
 exports.MAX_RETRIES = 3;
 exports.BASE_RETRY_DELAY_MS = 2_000;
-exports.INTER_CHUNK_DELAY_MS = 1_500;
+exports.INTER_BATCH_DELAY_MS = 1_500;
+exports.INTER_LEAF_DELAY_MS = 200;
+exports.PER_LEAF_FALLBACK_RATIO = 0.5;
+exports.GITHUB_REPO_URL = 'https://github.com/ibodev1/glotto';
+exports.CONFIG_FILE_NAME = 'glotto.config.json';
 exports.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: ${exports.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: ${exports.DEFAULT_PROVIDER})
+  -m, --model         Model name for the selected provider (optional)
+  -i, --input         Path to source JSON file (required)
+  -o, --output        Target JSON file path. Comma-separated for multi-target (required)
+  -f, --from          Source language (required)
+  -t, --to            Target language. Comma-separated for multi-target (required)
+  --url               Custom base URL for OpenAI/Anthropic (optional)
+  --config            Path to a glotto.config.json (default: ./glotto.config.json if present)
+  --stats             Print AI usage stats (input/output tokens, calls) at the end
+  --incremental       Translate only missing/empty keys when the target file already exists
+  --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: ${exports.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 -f english -t "turkish,french" -o "tr.json,fr.json"
+  glotto --key {{key}} -i en.json -o tr.json -f english -t turkish --incremental
+  glotto --key {{key}} -i en.json -o tr.json -f english -t turkish --stats
+  glotto --key {{key}} --config ./glotto.config.json
+  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/script/src/diff.d.ts

@@ -0,0 +1,4 @@
+import type { JsonValue, Leaf } from './types.js';
+export declare function findMissingLeaves(sourceLeaves: Leaf[], existingTarget: JsonValue): Leaf[];
+export declare function mergeTranslations(existingTarget: JsonValue, sourceLeaves: Leaf[], translations: Map<number, string>): JsonValue;
+//# sourceMappingURL=diff.d.ts.map

package/script/src/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/src/diff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,IAAI,EAAQ,MAAM,YAAY,CAAC;AAyBxD,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,IAAI,EAAE,EAAE,cAAc,EAAE,SAAS,GAAG,IAAI,EAAE,CAYzF;AASD,wBAAgB,iBAAiB,CAC/B,cAAc,EAAE,SAAS,EACzB,YAAY,EAAE,IAAI,EAAE,EACpB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC,SAAS,CAYX"}

package/script/src/diff.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findMissingLeaves = findMissingLeaves;
+exports.mergeTranslations = mergeTranslations;
+const translator_js_1 = require("./translator.js");
+function getPath(root, path) {
+    let node = root;
+    for (const key of path) {
+        if (node === null || typeof node !== 'object') {
+            return undefined;
+        }
+        const container = node;
+        if (!(key in container)) {
+            return undefined;
+        }
+        node = container[key];
+    }
+    return node;
+}
+function isPresentTranslation(value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    return value.trim().length > 0;
+}
+function findMissingLeaves(sourceLeaves, existingTarget) {
+    const missing = [];
+    for (const leaf of sourceLeaves) {
+        if (!leaf.translatable) {
+            continue;
+        }
+        const existingValue = getPath(existingTarget, leaf.path);
+        if (!isPresentTranslation(existingValue)) {
+            missing.push(leaf);
+        }
+    }
+    return missing;
+}
+function deepClone(value) {
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    return JSON.parse(JSON.stringify(value));
+}
+function mergeTranslations(existingTarget, sourceLeaves, translations) {
+    const clone = deepClone(existingTarget);
+    for (const leaf of sourceLeaves) {
+        if (!translations.has(leaf.id)) {
+            continue;
+        }
+        if (leaf.path.length === 0) {
+            return translations.get(leaf.id);
+        }
+        (0, translator_js_1.setPath)(clone, leaf.path, translations.get(leaf.id));
+    }
+    return clone;
+}

package/script/src/file.d.ts

@@ -1,10 +1,6 @@
-import type { ChunkInfo, JsonObject } from './types.js';
-export declare const resolvePath: (...paths: string[]) => string;
-export declare const getImportJson: <T = JsonObject>(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>;
+import type { JsonValue } from './types.js';
+export declare function resolvePath(...paths: string[]): string;
+export declare function getImportJson<T = JsonValue>(input: string): Promise<T>;
+export declare function writeOutput(outputPath: string, content: string): Promise<void>;
+export declare function readJsonIfExists<T = JsonValue>(path: string): Promise<T | null>;
 //# sourceMappingURL=file.d.ts.map

package/script/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,wBAAgB,WAAW,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAEtD;AAED,wBAAsB,aAAa,CAAC,CAAC,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAO5E;AAED,wBAAsB,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpF;AAED,wBAAsB,gBAAgB,CAAC,CAAC,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAcrF"}