@ai-translate/cli 0.1.0

package/dist/src-Cnnq284f.mjs

@@ -0,0 +1,947 @@
+import { auditCatalogs, defineConfig, defineConfig as defineConfig$1, resolveStateScope, syncCatalogs, usesGeneratorSelfCheck, validateCatalogs, withTranslationIssueCache } from "@ai-translate/core";
+import { adoptExistingTranslations } from "@ai-translate/fs-json";
+import { existsSync, promises } from "node:fs";
+import * as path from "node:path";
+import { config, parse } from "dotenv";
+import { createJiti } from "jiti";
+import { detectProject, renderConfig } from "@ai-translate/next";
+import { randomUUID } from "node:crypto";
+import * as os from "node:os";
+import { supportsScopedSave } from "@ai-translate/core/types";
+//#region src/config.ts
+const CONFIG_CANDIDATES = [
+	"ai-translate.config.ts",
+	"ai-translate.config.mts",
+	"ai-translate.config.js",
+	"ai-translate.config.mjs"
+];
+function isAiTranslateConfig(value) {
+	return typeof value === "object" && value !== null && "catalogs" in value && "provider" in value && "sourceLocale" in value && "state" in value && "targetLocales" in value;
+}
+function findConfigPath(cwd, explicitPath) {
+	if (explicitPath) return path.resolve(cwd, explicitPath);
+	for (const candidate of CONFIG_CANDIDATES) {
+		const fullPath = path.join(cwd, candidate);
+		if (existsSync(fullPath)) return fullPath;
+	}
+	throw new Error(`Unable to find ai-translate config in ${cwd}. Expected one of: ${CONFIG_CANDIDATES.join(", ")}`);
+}
+async function loadEnvFiles(cwd) {
+	const nodeEnv = process.env.NODE_ENV;
+	const candidates = [
+		".env",
+		".env.local",
+		nodeEnv ? `.env.${nodeEnv}` : void 0,
+		nodeEnv ? `.env.${nodeEnv}.local` : void 0
+	].filter((value) => value !== void 0);
+	const merged = {};
+	for (const fileName of candidates) {
+		const filePath = path.join(cwd, fileName);
+		try {
+			const raw = await promises.readFile(filePath, "utf8");
+			Object.assign(merged, parse(raw));
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+	}
+	config({
+		override: false,
+		path: candidates.map((candidate) => path.join(cwd, candidate)),
+		processEnv: process.env
+	});
+	return merged;
+}
+async function loadConfig(cwd, explicitPath) {
+	const configPath = findConfigPath(cwd, explicitPath);
+	const loaded = await createJiti(import.meta.url, {
+		interopDefault: true,
+		moduleCache: false
+	}).import(configPath);
+	const resolved = typeof loaded === "object" && loaded !== null && "default" in loaded ? loaded.default ?? loaded : loaded;
+	if (!isAiTranslateConfig(resolved)) throw new Error(`Config file ${configPath} did not export an ai-translate config object.`);
+	return {
+		config: defineConfig(resolved),
+		configPath
+	};
+}
+//#endregion
+//#region src/init.ts
+const CONFIG_FILENAME = "ai-translate.config.ts";
+const DEFAULT_AI_SDK_PACKAGE = "@ai-sdk/openai";
+/** Packages a generated config imports from, whichever provider it wires up. */
+const REQUIRED_PACKAGES = ["@ai-translate/cli", "@ai-translate/fs-json"];
+function describe(setup) {
+	return [
+		`Detected ${setup.displayName}:`,
+		...setup.evidence.map((item) => `  - ${item.detail} (${item.source})`),
+		`  - Source locale ${setup.plan.sourceLocale}, ${String(setup.plan.targetLocales.length)} target locale(s): ${setup.plan.targetLocales.join(", ")}`
+	];
+}
+async function missingPackages(cwd, plan, options) {
+	const expected = [
+		...REQUIRED_PACKAGES,
+		...plan.messageFormat === "plain" ? [] : ["@ai-translate/message-formats"],
+		...options.provider === "ai-sdk" ? [
+			"@ai-translate/provider-ai-sdk",
+			"ai",
+			options.providerPackage ?? DEFAULT_AI_SDK_PACKAGE
+		] : ["@ai-translate/provider-openai"]
+	];
+	try {
+		const raw = await promises.readFile(path.join(cwd, "package.json"), "utf8");
+		const manifest = JSON.parse(raw);
+		const declared = /* @__PURE__ */ new Set([...Object.keys(manifest.dependencies ?? {}), ...Object.keys(manifest.devDependencies ?? {})]);
+		return expected.filter((name) => !declared.has(name));
+	} catch {
+		return expected;
+	}
+}
+function chooseSetup(setups, requested) {
+	if (requested !== void 0) {
+		const match = setups.find((setup) => setup.integrationId === requested);
+		if (match === void 0) throw new Error(`No ${requested} setup was detected. Detected: ${setups.map((setup) => setup.integrationId).join(", ") || "none"}.`);
+		return match;
+	}
+	const [best, ...rest] = setups;
+	if (best === void 0) throw new Error("No supported Next.js localization setup was found. ai-translate init currently recognises next-intl and i18next. Write ai-translate.config.ts by hand, or run init from the directory holding package.json and your locale files.");
+	if (rest.length > 0 && rest[0]?.confidence === best.confidence) throw new Error(`Found more than one localization setup (${setups.map((setup) => setup.integrationId).join(", ")}). Re-run with --integration <id> to choose.`);
+	return best;
+}
+/**
+* Detects the project's localization setup and writes a config for it.
+*
+* Nothing else is touched. Installing packages, wiring scripts, and editing the
+* Next.js config stay in the user's hands, so `init` on an unfamiliar repository
+* produces exactly one new file and a list of instructions.
+*/
+async function runInit(cwd, options = {}) {
+	const setups = await detectProject(cwd, options.integrations === void 0 ? {} : { integrations: options.integrations });
+	const setup = chooseSetup(setups, options.integration);
+	const contents = renderConfig(setup.plan, {
+		...options.model === void 0 ? {} : { model: options.model },
+		...options.provider === void 0 ? {} : { provider: options.provider },
+		...options.providerPackage === void 0 ? {} : { providerPackage: options.providerPackage }
+	});
+	const configPath = path.join(cwd, CONFIG_FILENAME);
+	const lines = describe(setup);
+	for (const warning of setup.plan.warnings) lines.push(`  ! ${warning}`);
+	const others = setups.filter((candidate) => candidate !== setup);
+	if (others.length > 0) lines.push(`Also detected, not used: ${others.map((candidate) => candidate.displayName).join(", ")}.`);
+	if (options.preview === true) {
+		lines.push("", `Would write ${CONFIG_FILENAME}:`, "", contents);
+		return {
+			configPath: null,
+			lines,
+			setup
+		};
+	}
+	if (await promises.access(configPath).then(() => true).catch(() => false) && options.force !== true) throw new Error(`${CONFIG_FILENAME} already exists. Pass --force to overwrite it.`);
+	await promises.writeFile(configPath, contents, "utf8");
+	lines.push("", `Wrote ${CONFIG_FILENAME}.`, "", "Next steps:");
+	const install = await missingPackages(cwd, setup.plan, options);
+	let step = 1;
+	if (install.length > 0) lines.push(`  ${String(step++)}. Install: ${install.join(" ")}`);
+	const apiKeyVariable = options.provider === "ai-sdk" ? `the API key your ${options.providerPackage ?? DEFAULT_AI_SDK_PACKAGE} provider reads` : "OPENAI_API_KEY";
+	lines.push(`  ${String(step++)}. Set ${apiKeyVariable}, in your shell or in .env.local.`, `  ${String(step++)}. Review the model and locale list in ${CONFIG_FILENAME}.`, `  ${String(step++)}. Run "ai-translate validate" to confirm the config loads.`, `  ${String(step++)}. Run "ai-translate check" to see what a sync would do.`, `  ${String(step)}. Run "ai-translate sync" to translate.`);
+	return {
+		configPath,
+		lines,
+		setup
+	};
+}
+//#endregion
+//#region src/transaction.ts
+const DURABLE_TRANSACTION_STATE_STORE = Symbol.for("@ai-translate/fs-json/durable-transaction-state-store");
+function cloneState(state) {
+	return structuredClone(state);
+}
+function cloneEntry(entry) {
+	return {
+		...entry,
+		address: entry.address.map((segment) => ({ ...segment })),
+		...entry.meta === void 0 ? {} : { meta: { ...entry.meta } },
+		...entry.tokens === void 0 ? {} : { tokens: entry.tokens.map((token) => ({ ...token })) }
+	};
+}
+/** Adapter state may contain parser-owned class instances, so retain it while
+* isolating the mutable translation entries. Staged writes are subsequently
+* serialized and reloaded by the real adapter to obtain isolated live state. */
+function cloneDocument(document) {
+	return {
+		entries: document.entries.map(cloneEntry),
+		...document.reconciliation === void 0 ? {} : { reconciliation: {
+			...document.reconciliation.previousPointers === void 0 ? {} : { previousPointers: { ...document.reconciliation.previousPointers } },
+			...document.reconciliation.retiredStateKeys === void 0 ? {} : { retiredStateKeys: [...document.reconciliation.retiredStateKeys] }
+		} },
+		ref: { ...document.ref },
+		state: document.state,
+		...document.structureDigest === void 0 ? {} : { structureDigest: document.structureDigest }
+	};
+}
+function restoreDocumentRef(document, ref) {
+	return cloneDocument({
+		...document,
+		ref: { ...ref }
+	});
+}
+function documentKey(ref) {
+	return [
+		ref.catalogId,
+		ref.format,
+		ref.locale,
+		ref.path,
+		ref.unitId
+	].join("\0");
+}
+var StagedStateStore = class {
+	dirty = false;
+	snapshot;
+	constructor(initial) {
+		this.snapshot = cloneState(initial);
+	}
+	hasChanges() {
+		return this.dirty;
+	}
+	load() {
+		return Promise.resolve(cloneState(this.snapshot));
+	}
+	save(state) {
+		this.snapshot = cloneState(state);
+		this.dirty = true;
+		return Promise.resolve();
+	}
+	stagedSnapshot() {
+		return cloneState(this.snapshot);
+	}
+	withLock(operation) {
+		return operation();
+	}
+};
+async function readOriginal(filePath) {
+	try {
+		const [original, stats] = await Promise.all([promises.readFile(filePath), promises.stat(filePath)]);
+		return {
+			mode: stats.mode,
+			original
+		};
+	} catch (error) {
+		if (error.code === "ENOENT") return {
+			mode: void 0,
+			original: null
+		};
+		throw error;
+	}
+}
+async function writeFileAtomic(filePath, contents, mode) {
+	await promises.mkdir(path.dirname(filePath), { recursive: true });
+	const temporaryPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.ai-translate-${randomUUID()}`);
+	try {
+		await promises.writeFile(temporaryPath, contents);
+		if (mode !== void 0) await promises.chmod(temporaryPath, mode);
+		await promises.rename(temporaryPath, filePath);
+	} finally {
+		await promises.rm(temporaryPath, { force: true });
+	}
+}
+var StagedCatalogs = class {
+	catalogs;
+	sourceLocale;
+	files = /* @__PURE__ */ new Map();
+	pendingRefs = /* @__PURE__ */ new Map();
+	tempRoot;
+	constructor(catalogs, sourceLocale) {
+		this.catalogs = catalogs;
+		this.sourceLocale = sourceLocale;
+	}
+	adapters() {
+		return this.catalogs.map((catalog) => this.createAdapter(catalog));
+	}
+	async cleanup() {
+		if (this.tempRoot !== void 0) await promises.rm(this.tempRoot, {
+			force: true,
+			recursive: true
+		});
+	}
+	async promote() {
+		for (const staged of this.files.values()) await writeFileAtomic(staged.realPath, await promises.readFile(staged.tempPath), staged.mode);
+	}
+	async durableChanges() {
+		return Promise.all([...this.files.values()].map(async (staged) => ({
+			...staged.mode === void 0 ? {} : { mode: staged.mode },
+			next: await promises.readFile(staged.tempPath),
+			original: staged.original,
+			path: staged.realPath
+		})));
+	}
+	async rollback() {
+		const failures = [];
+		for (const staged of this.files.values()) try {
+			if (staged.original === null) await promises.rm(staged.realPath, { force: true });
+			else await writeFileAtomic(staged.realPath, staged.original, staged.mode);
+		} catch (error) {
+			failures.push(error);
+		}
+		if (failures.length > 0) throw new AggregateError(failures, "Failed to restore localized documents after commit.");
+	}
+	async stageFile(realPath) {
+		const existing = this.files.get(realPath);
+		if (existing) return existing;
+		this.tempRoot ??= await promises.mkdtemp(path.join(os.tmpdir(), "ai-translate-stage-"));
+		const { mode, original } = await readOriginal(realPath);
+		const tempPath = path.join(this.tempRoot, `${String(this.files.size)}${path.extname(realPath) || ".document"}`);
+		if (original !== null) await promises.writeFile(tempPath, original);
+		const staged = {
+			mode,
+			original,
+			realPath,
+			tempPath
+		};
+		this.files.set(realPath, staged);
+		return staged;
+	}
+	async loadStaged(catalog, ref) {
+		const staged = this.files.get(ref.path);
+		if (!staged) {
+			const document = await catalog.loadDocument(ref);
+			return document === null ? null : cloneDocument(document);
+		}
+		const tempRef = {
+			...ref,
+			path: staged.tempPath
+		};
+		const document = await catalog.loadDocument(tempRef);
+		return document === null ? null : restoreDocumentRef(document, ref);
+	}
+	async writeStaged(catalog, document) {
+		const staged = await this.stageFile(document.ref.path);
+		const tempRef = {
+			...document.ref,
+			path: staged.tempPath
+		};
+		const stagedDocument = await catalog.loadDocument(tempRef);
+		await catalog.writeDocument({
+			...cloneDocument(document),
+			ref: tempRef,
+			state: stagedDocument === null || catalog.mergeStagedState === void 0 ? document.state : catalog.mergeStagedState({
+				document,
+				staged: stagedDocument
+			})
+		});
+		if (await catalog.loadDocument(tempRef) === null) throw new Error(`Catalog "${catalog.id}" did not persist staged document ${document.ref.path}.`);
+		this.pendingRefs.set(documentKey(document.ref), {
+			catalog,
+			ref: { ...document.ref }
+		});
+		for (const pending of this.pendingRefs.values()) if (pending.ref.path === document.ref.path) {
+			const pendingTempRef = {
+				...pending.ref,
+				path: staged.tempPath
+			};
+			if (await pending.catalog.loadDocument(pendingTempRef) === null) throw new Error(`Catalog "${pending.catalog.id}" could not reload staged document ${pending.ref.path}.`);
+		}
+	}
+	createAdapter(catalog) {
+		const mergeStagedState = catalog.mergeStagedState?.bind(catalog);
+		return {
+			createDocumentRef: (sourceRef, locale) => catalog.createDocumentRef(sourceRef, locale),
+			id: catalog.id,
+			listDocumentRefs: (sourceLocale) => catalog.listDocumentRefs(sourceLocale),
+			loadDocument: (ref) => this.loadStaged(catalog, ref),
+			...mergeStagedState === void 0 ? {} : { mergeStagedState },
+			reconcileDocument: async (args) => {
+				return cloneDocument(await catalog.reconcileDocument({
+					...args.history === void 0 ? {} : { history: args.history.map((entry) => structuredClone(entry)) },
+					ref: { ...args.ref },
+					source: cloneDocument(args.source),
+					target: args.target === null ? null : cloneDocument(args.target)
+				}));
+			},
+			...catalog.scaffoldLocale === void 0 ? {} : { scaffoldLocale: (options) => this.scaffoldCatalog(catalog, options) },
+			writeDocument: (document) => this.writeStaged(catalog, document)
+		};
+	}
+	async scaffoldCatalog(catalog, options) {
+		const strategy = options.strategy ?? "copy-source";
+		const fromLocale = strategy === "copy-source" ? this.sourceLocale : options.fromLocale ?? this.sourceLocale;
+		const refs = await catalog.listDocumentRefs(fromLocale);
+		if (strategy === "empty") return {
+			catalogId: catalog.id,
+			createdDocuments: 0,
+			locale: options.locale,
+			skippedDocuments: refs.length,
+			strategy
+		};
+		let createdDocuments = 0;
+		let skippedDocuments = 0;
+		const adapter = this.createAdapter(catalog);
+		for (const sourceRef of refs) {
+			const targetRef = adapter.createDocumentRef(sourceRef, options.locale);
+			if (await adapter.loadDocument(targetRef) !== null) {
+				skippedDocuments += 1;
+				continue;
+			}
+			const source = await adapter.loadDocument(sourceRef);
+			if (source === null) {
+				skippedDocuments += 1;
+				continue;
+			}
+			await adapter.writeDocument(await adapter.reconcileDocument({
+				ref: targetRef,
+				source,
+				target: null
+			}));
+			createdDocuments += 1;
+		}
+		return {
+			catalogId: catalog.id,
+			createdDocuments,
+			locale: options.locale,
+			skippedDocuments,
+			strategy
+		};
+	}
+};
+function commitFailure(commitError, rollbackErrors) {
+	return rollbackErrors.length === 0 ? commitError instanceof Error ? commitError : new Error(String(commitError)) : new AggregateError([commitError, ...rollbackErrors], "Translation commit failed and could not be completely rolled back.");
+}
+function durableStateStore(state) {
+	if (typeof state === "object" && state !== null) {
+		const candidate = state[DURABLE_TRANSACTION_STATE_STORE];
+		if (typeof candidate === "object" && candidate !== null && "commit" in candidate && typeof candidate.commit === "function") return candidate;
+	}
+	return null;
+}
+async function runStagedCatalogTransaction(config, operation, shouldCommit = () => true, scope) {
+	const saveScope = supportsScopedSave(config.state) ? scope : void 0;
+	return config.state.withLock(async () => {
+		const initialState = await config.state.load(saveScope);
+		const stagedState = new StagedStateStore(initialState);
+		const stagedCatalogs = new StagedCatalogs(config.catalogs, config.sourceLocale);
+		const stagedConfig = {
+			...config,
+			catalogs: stagedCatalogs.adapters(),
+			state: stagedState
+		};
+		try {
+			const result = await operation(stagedConfig);
+			if (!shouldCommit(result)) return result;
+			const durableStore = durableStateStore(config.state);
+			if (durableStore !== null) {
+				const documents = await stagedCatalogs.durableChanges();
+				if (documents.length > 0 || stagedState.hasChanges()) await durableStore.commit({
+					documents,
+					initialState: cloneState(initialState),
+					nextState: stagedState.stagedSnapshot(),
+					...saveScope === void 0 ? {} : { scope: saveScope }
+				});
+			} else {
+				let stateSaveAttempted = false;
+				try {
+					await stagedCatalogs.promote();
+					if (stagedState.hasChanges()) {
+						stateSaveAttempted = true;
+						await config.state.save(stagedState.stagedSnapshot(), saveScope);
+					}
+				} catch (error) {
+					const rollbackErrors = [];
+					try {
+						await stagedCatalogs.rollback();
+					} catch (rollbackError) {
+						rollbackErrors.push(rollbackError);
+					}
+					if (stateSaveAttempted) try {
+						await config.state.save(cloneState(initialState), saveScope);
+					} catch (rollbackError) {
+						rollbackErrors.push(rollbackError);
+					}
+					throw commitFailure(error, rollbackErrors);
+				}
+			}
+			return result;
+		} finally {
+			await stagedCatalogs.cleanup();
+		}
+	});
+}
+//#endregion
+//#region src/index.ts
+function requireOptionValue(optionName, value) {
+	if (value === void 0) throw new Error(`Option "--${optionName}" requires a value.`);
+	return value;
+}
+function requireProviderChoice(value) {
+	if (value !== "ai-sdk" && value !== "openai") throw new Error(`Option "--provider" accepts "openai" or "ai-sdk", not "${value}".`);
+	return value;
+}
+function requireIdenticalToSourcePolicy(value) {
+	if (value !== "adopt" && value !== "skip") throw new Error(`Option "--identical-to-source" accepts "adopt" or "skip", not "${value}".`);
+	return value;
+}
+function requireNonNegativeIntegerOption(optionName, value) {
+	const rawValue = requireOptionValue(optionName, value);
+	const parsedValue = Number(rawValue);
+	if (!Number.isSafeInteger(parsedValue) || parsedValue < 0) throw new Error(`Option "--${optionName}" requires a non-negative integer.`);
+	return parsedValue;
+}
+async function validateConfig(config, configPath, options) {
+	return {
+		...await validateCatalogs(config, options),
+		configPath
+	};
+}
+const DEFAULT_SEMANTIC_REPAIR_ROUNDS = 0;
+function printSyncSummary(result, semanticAudit, semanticRepairRounds = 0) {
+	const pendingTranslationReasons = summarizePendingTranslationReasons(result);
+	const failedTranslationIssues = summarizeFailedTranslationIssues(result);
+	console.log(JSON.stringify({
+		dryRun: result.dryRun,
+		metrics: result.metrics,
+		...result.dryRun && Object.keys(pendingTranslationReasons).length > 0 ? { pendingTranslationReasons } : {},
+		...semanticAudit === void 0 ? {} : {
+			semanticAudit,
+			semanticRepairRounds
+		},
+		...failedTranslationIssues === void 0 ? {} : { failedTranslationIssues }
+	}, null, 2));
+}
+function summarizeFailedTranslationIssues(result) {
+	if (result.metrics.failedEntries === 0) return;
+	const errors = result.documents.flatMap((document) => document.issues.filter((issue) => issue.severity === "error").map((issue) => ({
+		catalogId: document.catalogId,
+		code: issue.code,
+		locale: document.locale,
+		message: issue.message,
+		path: document.path,
+		unitId: document.unitId
+	})));
+	const counts = {};
+	for (const issue of errors) counts[issue.code] = (counts[issue.code] ?? 0) + 1;
+	return {
+		counts: Object.fromEntries(Object.entries(counts).toSorted(([leftCode, leftCount], [rightCode, rightCount]) => rightCount - leftCount || leftCode.localeCompare(rightCode))),
+		examples: errors.slice(0, 25)
+	};
+}
+function summarizePendingTranslationReasons(result) {
+	const summary = {};
+	for (const document of result.documents) for (const [reason, count] of Object.entries(document.pendingTranslationReasons ?? {})) summary[reason] = (summary[reason] ?? 0) + count;
+	return Object.fromEntries(Object.entries(summary).toSorted(([leftReason, leftCount], [rightReason, rightCount]) => rightCount - leftCount || leftReason.localeCompare(rightReason)));
+}
+function dryRunBudgetError(config, result) {
+	if (!result.dryRun || config.validation?.dryRunBudget === void 0) return;
+	const budget = config.validation.dryRunBudget;
+	if (budget.maxPendingTranslations !== void 0 && result.metrics.translatedEntries > budget.maxPendingTranslations) return `Translation dry-run planned ${String(result.metrics.translatedEntries)} provider translations, exceeding the configured budget of ${String(budget.maxPendingTranslations)}.`;
+	const reasons = summarizePendingTranslationReasons(result);
+	const forbidden = (budget.forbiddenPendingTranslationReasons ?? []).filter((reason) => (reasons[reason] ?? 0) > 0);
+	return forbidden.length === 0 ? void 0 : `Translation dry-run included forbidden selection reasons: ${forbidden.map((reason) => `${reason} (${String(reasons[reason] ?? 0)})`).join(", ")}.`;
+}
+function assertDryRunBudget(config, result) {
+	const error = dryRunBudgetError(config, result);
+	if (error !== void 0) throw new Error(error);
+}
+async function convergeSemanticAudits(config, options) {
+	let sync = await syncCatalogs(config, options);
+	if (options.dryRun === true || sync.metrics.failedEntries > 0 || (config.semanticAudits?.length ?? 0) === 0 || usesGeneratorSelfCheck(config)) return {
+		audit: void 0,
+		repairRounds: 0,
+		sync
+	};
+	let audit = await auditCatalogs(config, options);
+	let repairRounds = 0;
+	const maxSemanticRepairRounds = config.validation?.semanticRepairAttempts ?? DEFAULT_SEMANTIC_REPAIR_ROUNDS;
+	const repairOptions = { ...options };
+	delete repairOptions.forceRetranslate;
+	delete repairOptions.forceRetranslatePaths;
+	while (audit.retranslate > 0 && repairRounds < maxSemanticRepairRounds) {
+		repairRounds += 1;
+		sync = await syncCatalogs(config, repairOptions);
+		if (sync.metrics.failedEntries > 0) break;
+		audit = await auditCatalogs(config, options);
+	}
+	return {
+		audit,
+		repairRounds,
+		sync
+	};
+}
+async function syncWithSemanticAuditConvergence(config, options) {
+	if (options.dryRun === true) return convergeSemanticAudits(config, options);
+	return runStagedCatalogTransaction(config, (stagedConfig) => convergeSemanticAudits(stagedConfig, options), (result) => semanticAuditConvergenceError(result) === void 0, resolveStateScope(config, options));
+}
+function semanticAuditConvergenceError(result) {
+	if (result.sync.metrics.failedEntries > 0) return "Sync completed with failed translation entries.";
+	if ((result.audit?.unresolved ?? 0) > 0) return "Sync completed with unresolved semantic audits. Review or refresh the audit findings.";
+	if ((result.audit?.retranslate ?? 0) > 0) return `Semantic audit rejected translations after ${String(result.repairRounds)} configured repair round(s).`;
+	if (result.audit?.issues.some((issue) => issue.severity === "error")) return "Semantic audit completed with unresolved or unsafe translations.";
+}
+function assertSemanticAuditConvergence(result) {
+	const error = semanticAuditConvergenceError(result);
+	if (error !== void 0) throw new Error(error);
+}
+function buildSyncOptions(options) {
+	const syncOptions = {};
+	if (options.catalogIds && options.catalogIds.length > 0) syncOptions.catalogIds = options.catalogIds;
+	if (options.dryRun !== void 0) syncOptions.dryRun = options.dryRun;
+	if (options.forceRetranslate !== void 0) syncOptions.forceRetranslate = options.forceRetranslate;
+	if (options.forceRetranslatePaths && options.forceRetranslatePaths.length > 0) {
+		syncOptions.forceRetranslate = true;
+		syncOptions.forceRetranslatePaths = options.forceRetranslatePaths;
+	}
+	if (options.includePaths && options.includePaths.length > 0) syncOptions.includePaths = options.includePaths;
+	if (options.locales && options.locales.length > 0) syncOptions.locales = options.locales;
+	if (options.maxPendingTranslations !== void 0) syncOptions.maxPendingTranslations = options.maxPendingTranslations;
+	if (options.unitIds && options.unitIds.length > 0) syncOptions.unitIds = options.unitIds;
+	return syncOptions;
+}
+function projectStateLocales(state, locales) {
+	if (locales === void 0 || locales.length === 0) return state;
+	const included = new Set(locales);
+	return {
+		entries: Object.fromEntries(Object.entries(state.entries).filter(([, entry]) => included.has(entry.locale))),
+		version: state.version
+	};
+}
+function hasStoredSemanticAudits(state) {
+	return Object.values(state.entries).some((entry) => Object.keys(entry.validationAudits ?? {}).length > 0);
+}
+const EMPTY_SEMANTIC_AUDIT = {
+	accepted: 0,
+	audited: 0,
+	cached: 0,
+	checked: 0,
+	issues: [],
+	retranslate: 0,
+	unresolved: 0
+};
+async function scaffoldLocale(config, locale, options = {}) {
+	return Promise.all(config.catalogs.map(async (catalog) => {
+		if (!catalog.scaffoldLocale) return null;
+		return catalog.scaffoldLocale({
+			...options.fromLocale === void 0 ? {} : { fromLocale: options.fromLocale },
+			locale,
+			...options.strategy === void 0 ? {} : { strategy: options.strategy }
+		});
+	}));
+}
+function printHelp() {
+	console.log(`ai-translate
+
+Usage:
+  ai-translate init [--integration <next-intl|i18next>] [--provider <openai|ai-sdk>] [--provider-package <@ai-sdk/...>] [--model <id>] [--preview] [--force]
+  ai-translate validate [--config <path>]
+  ai-translate check [--config <path>] [--locale <locale>] [--catalog <id>] [--unit <id>] [--include-path <json-pointer>] [--max-pending-translations <count>]
+  ai-translate audit [--check] [--refresh] [--config <path>] [--locale <locale>] [--catalog <id>] [--unit <id>] [--include-path <json-pointer>]
+  ai-translate sync [--config <path>] [--dry-run] [--force-retranslate] [--force-retranslate-path <json-pointer>] [--include-path <json-pointer>] [--locale <locale>] [--catalog <id>] [--unit <id>] [--max-pending-translations <count>]
+  ai-translate new-locale <locale> [--from <locale>] [--strategy <strategy>] [--config <path>]
+  ai-translate scaffold-locale <locale> --from <locale> [--strategy <strategy>] [--config <path>]
+  ai-translate adopt [--identical-to-source <adopt|skip>] [--dry-run] [--config <path>]
+  ai-translate --help
+  ai-translate --version`);
+}
+function parseCommand(argv) {
+	const options = {};
+	const positionals = [];
+	let command;
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (arg === void 0) continue;
+		if (arg === "--help" || arg === "-h") return {
+			command: "help",
+			options,
+			positionals
+		};
+		if (arg === "--version" || arg === "-v") return {
+			command: "version",
+			options,
+			positionals
+		};
+		if (arg.startsWith("--")) {
+			const [flag = "", inlineValue] = arg.slice(2).split("=", 2);
+			if (flag.length === 0) throw new Error("Encountered an empty option flag.");
+			const nextValue = inlineValue ?? argv[index + 1];
+			switch (flag) {
+				case "check":
+					options.auditCheck = true;
+					break;
+				case "config":
+					options.config = requireOptionValue(flag, nextValue);
+					if (inlineValue === void 0) index += 1;
+					break;
+				case "catalog":
+					(options.catalogIds ??= []).push(requireOptionValue(flag, nextValue));
+					if (inlineValue === void 0) index += 1;
+					break;
+				case "dry-run":
+					options.dryRun = true;
+					break;
+				case "force":
+					options.force = true;
+					break;
+				case "force-retranslate":
+					options.forceRetranslate = true;
+					break;
+				case "force-retranslate-path":
+					(options.forceRetranslatePaths ??= []).push(requireOptionValue(flag, nextValue));
+					if (inlineValue === void 0) index += 1;
+					break;
+				case "from":
+					options.from = requireOptionValue(flag, nextValue);
+					if (inlineValue === void 0) index += 1;
+					break;
+				case "include-path":
+					(options.includePaths ??= []).push(requireOptionValue(flag, nextValue));
+					if (inlineValue === void 0) index += 1;
+					break;
+				case "integration":
+					options.integration = requireOptionValue(flag, nextValue);
+					if (inlineValue === void 0) index += 1;
+					break;
+				case "locale":
+					(options.locales ??= []).push(requireOptionValue(flag, nextValue));
+					if (inlineValue === void 0) index += 1;
+					break;
+				case "model":
+					options.model = requireOptionValue(flag, nextValue);
+					if (inlineValue === void 0) index += 1;
+					break;
+				case "preview":
+					options.preview = true;
+					break;
+				case "provider":
+					options.provider = requireOptionValue(flag, nextValue);
+					if (inlineValue === void 0) index += 1;
+					break;
+				case "provider-package":
+					options.providerPackage = requireOptionValue(flag, nextValue);
+					if (inlineValue === void 0) index += 1;
+					break;
+				case "max-pending-translations":
+					options.maxPendingTranslations = requireNonNegativeIntegerOption(flag, nextValue);
+					if (inlineValue === void 0) index += 1;
+					break;
+				case "identical-to-source":
+					options.identicalToSource = requireIdenticalToSourcePolicy(requireOptionValue(flag, nextValue));
+					if (inlineValue === void 0) index += 1;
+					break;
+				case "refresh":
+					options.refresh = true;
+					break;
+				case "strategy":
+					options.strategy = requireOptionValue(flag, nextValue);
+					if (inlineValue === void 0) index += 1;
+					break;
+				case "unit":
+					(options.unitIds ??= []).push(requireOptionValue(flag, nextValue));
+					if (inlineValue === void 0) index += 1;
+					break;
+				default: throw new Error(`Unknown option "--${flag}".`);
+			}
+			continue;
+		}
+		if (!command) {
+			command = arg;
+			continue;
+		}
+		positionals.push(arg);
+	}
+	const parsedCommand = {
+		options,
+		positionals
+	};
+	if (command !== void 0) parsedCommand.command = command;
+	return parsedCommand;
+}
+async function runCli(argv = process.argv.slice(2), cwd = process.cwd()) {
+	try {
+		const parsed = parseCommand(argv);
+		if (!parsed.command || parsed.command === "help") {
+			printHelp();
+			return 0;
+		}
+		if (parsed.command === "version") {
+			console.log("0.0.0");
+			return 0;
+		}
+		switch (parsed.command) {
+			case "init": {
+				const result = await runInit(cwd, {
+					force: parsed.options.force === true,
+					...parsed.options.integration === void 0 ? {} : { integration: parsed.options.integration },
+					...parsed.options.model === void 0 ? {} : { model: parsed.options.model },
+					preview: parsed.options.preview === true || parsed.options.dryRun === true,
+					...parsed.options.provider === void 0 ? {} : { provider: requireProviderChoice(parsed.options.provider) },
+					...parsed.options.providerPackage === void 0 ? {} : { providerPackage: parsed.options.providerPackage }
+				});
+				console.log(result.lines.join("\n"));
+				return 0;
+			}
+			case "validate": {
+				await loadEnvFiles(cwd);
+				const { config, configPath } = await loadConfig(cwd, parsed.options.config);
+				const summary = await validateConfig(config, configPath, buildSyncOptions(parsed.options));
+				console.log(JSON.stringify(summary, null, 2));
+				if (summary.issues.some((issue) => issue.severity === "error")) throw new Error("Validation failed.");
+				return 0;
+			}
+			case "check": {
+				await loadEnvFiles(cwd);
+				const { config, configPath } = await loadConfig(cwd, parsed.options.config);
+				const checkOptions = {
+					...buildSyncOptions(parsed.options),
+					...process.env.AI_TRANSLATE_CHECK_SNAPSHOT_LOCK === "1" ? { assumeStateLock: true } : {}
+				};
+				const stateSnapshot = projectStateLocales(await config.state.load(checkOptions.locales === void 0 ? void 0 : { locales: checkOptions.locales }), checkOptions.locales);
+				const checkConfig = {
+					...config,
+					state: {
+						load: () => Promise.resolve(stateSnapshot),
+						save: () => Promise.reject(/* @__PURE__ */ new Error("Translation check cannot persist translation state.")),
+						withLock: (operation) => config.state.withLock(operation)
+					}
+				};
+				const needsSemanticAudit = (checkConfig.semanticAudits?.length ?? 0) > 0 || hasStoredSemanticAudits(stateSnapshot);
+				const { auditResult, dryRunResult, validationResult } = await withTranslationIssueCache(async () => {
+					const checkedValidation = await validateConfig(checkConfig, configPath, {
+						...checkOptions,
+						acceptedProvenanceFastPath: true
+					});
+					const checkedDryRun = await syncCatalogs(checkConfig, {
+						...checkOptions,
+						dryRun: true
+					});
+					return {
+						auditResult: needsSemanticAudit ? await auditCatalogs(checkConfig, {
+							...checkOptions,
+							checkOnly: true
+						}) : EMPTY_SEMANTIC_AUDIT,
+						dryRunResult: checkedDryRun,
+						validationResult: checkedValidation
+					};
+				});
+				const hasValidationErrors = validationResult.issues.some((issue) => issue.severity === "error");
+				const hasPendingSync = dryRunResult.metrics.changedDocuments > 0 || dryRunResult.metrics.failedEntries > 0 || dryRunResult.metrics.staleManualEntries > 0 || dryRunResult.metrics.translatedEntries > 0;
+				const hasAuditErrors = auditResult.issues.some((issue) => issue.severity === "error");
+				console.log(JSON.stringify({
+					validation: validationResult,
+					audit: auditResult,
+					dryRun: dryRunResult.metrics
+				}, null, 2));
+				if (hasValidationErrors || hasPendingSync || hasAuditErrors) {
+					if (hasAuditErrors && !hasValidationErrors && !hasPendingSync) throw new Error("Translation check failed because semantic audit provenance is missing, stale, or unresolved. Run ai-translate audit --refresh.");
+					throw new Error("Translation check failed. Run ai-translate sync to reconcile localized content.");
+				}
+				return 0;
+			}
+			case "audit": {
+				await loadEnvFiles(cwd);
+				const { config } = await loadConfig(cwd, parsed.options.config);
+				const result = await auditCatalogs(config, {
+					...buildSyncOptions(parsed.options),
+					checkOnly: parsed.options.auditCheck ?? false,
+					refresh: parsed.options.refresh ?? false
+				});
+				console.log(JSON.stringify(result, null, 2));
+				if (result.issues.some((issue) => issue.severity === "error")) throw new Error(parsed.options.auditCheck ? "Semantic audit check failed. Run ai-translate audit --refresh." : "Semantic audit completed with unresolved or unsafe translations.");
+				return 0;
+			}
+			case "sync": {
+				await loadEnvFiles(cwd);
+				const { config } = await loadConfig(cwd, parsed.options.config);
+				const result = await withTranslationIssueCache(() => syncWithSemanticAuditConvergence(config, buildSyncOptions(parsed.options)));
+				printSyncSummary(result.sync, result.audit, result.repairRounds);
+				assertDryRunBudget(config, result.sync);
+				assertSemanticAuditConvergence(result);
+				return 0;
+			}
+			case "new-locale": {
+				const locale = parsed.positionals[0];
+				if (!locale) throw new Error("The \"new-locale\" command requires a <locale> argument.");
+				await loadEnvFiles(cwd);
+				const { config } = await loadConfig(cwd, parsed.options.config);
+				const fromLocale = parsed.options.from ?? config.sourceLocale;
+				const strategy = parsed.options.strategy ?? "copy-source";
+				if (parsed.options.dryRun && fromLocale !== config.sourceLocale) throw new Error("The \"new-locale\" command only supports --from <sourceLocale> when used with --dry-run.");
+				if (parsed.options.dryRun && strategy !== "copy-source") throw new Error("The \"new-locale\" command only supports --strategy copy-source when used with --dry-run.");
+				if (strategy !== "copy-source" && fromLocale === config.sourceLocale) throw new Error(`The "${strategy}" strategy requires --from <locale> to be a translated locale.`);
+				const syncOptions = {
+					...buildSyncOptions(parsed.options),
+					forceRetranslate: strategy === "copy-locale-and-retranslate",
+					locales: [locale]
+				};
+				const { result, scaffoldResults } = parsed.options.dryRun ? {
+					result: await convergeSemanticAudits(config, syncOptions),
+					scaffoldResults: []
+				} : await runStagedCatalogTransaction(config, async (stagedConfig) => {
+					const scaffoldResults = await scaffoldLocale(stagedConfig, locale, {
+						fromLocale,
+						strategy
+					});
+					return {
+						result: await convergeSemanticAudits(stagedConfig, syncOptions),
+						scaffoldResults
+					};
+				}, ({ result }) => semanticAuditConvergenceError(result) === void 0);
+				console.log(JSON.stringify({
+					dryRun: result.sync.dryRun,
+					fromLocale,
+					locale,
+					metrics: result.sync.metrics,
+					scaffoldResults,
+					...result.audit === void 0 ? {} : {
+						semanticAudit: result.audit,
+						semanticRepairRounds: result.repairRounds
+					},
+					strategy,
+					status: semanticAuditConvergenceError(result) === void 0 ? "ok" : "failed"
+				}, null, 2));
+				assertSemanticAuditConvergence(result);
+				return 0;
+			}
+			case "scaffold-locale": {
+				const locale = parsed.positionals[0];
+				if (!locale) throw new Error("The \"scaffold-locale\" command requires a <locale> argument.");
+				if (!parsed.options.from) throw new Error("The \"scaffold-locale\" command requires --from <locale>.");
+				await loadEnvFiles(cwd);
+				const { config } = await loadConfig(cwd, parsed.options.config);
+				const scaffoldResults = await scaffoldLocale(config, locale, {
+					fromLocale: parsed.options.from,
+					strategy: parsed.options.strategy ?? "copy-locale"
+				});
+				console.log(JSON.stringify({
+					fromLocale: parsed.options.from,
+					locale,
+					scaffoldResults,
+					strategy: parsed.options.strategy ?? "copy-locale",
+					status: "ok"
+				}, null, 2));
+				return 0;
+			}
+			case "adopt": {
+				await loadEnvFiles(cwd);
+				const { config } = await loadConfig(cwd, parsed.options.config);
+				const result = await adoptExistingTranslations({
+					catalogs: config.catalogs,
+					identicalToSource: parsed.options.identicalToSource ?? "adopt",
+					sourceLocale: config.sourceLocale,
+					targetLocales: config.targetLocales
+				});
+				if (!parsed.options.dryRun) await config.state.save(result.state);
+				console.log(JSON.stringify({
+					adopted: result.adopted,
+					dryRun: parsed.options.dryRun === true,
+					identicalToSource: result.identicalToSource,
+					status: "ok",
+					untranslated: result.untranslated
+				}, null, 2));
+				return 0;
+			}
+			default: throw new Error(`Unknown command "${parsed.command}".`);
+		}
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : `Unexpected CLI failure: ${String(error)}`);
+		return 1;
+	}
+}
+//#endregion
+export { loadEnvFiles as a, loadConfig as i, runCli as n, findConfigPath as r, defineConfig$1 as t };
+
+//# sourceMappingURL=src-Cnnq284f.mjs.map