@ai-translate/cli 0.2.3 → 0.4.0

package/dist/{src-Cnnq284f.mjs → src-SwBEpdIU.mjs}

@@ -1,10 +1,15 @@
+import { readFile } from "node:fs/promises";
 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 { appleIntegration, expoIntegration } from "@ai-translate/apple";
+import { detectProject, isLocaleTag, renderConfig, requiredConfigPackages } from "@ai-translate/integrations";
+import { builtinIntegrations } from "@ai-translate/next";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
 import { randomUUID } from "node:crypto";
 import * as os from "node:os";
 import { supportsScopedSave } from "@ai-translate/core/types";
@@ -65,86 +70,537 @@ async function loadConfig(cwd, explicitPath) {
 	};
 }
 //#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(", ")}`
-	];
+//#region src/init-project.ts
+const MANAGERS = [
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun"
+];
+const LOCKFILES = {
+	npm: ["package-lock.json", "npm-shrinkwrap.json"],
+	pnpm: ["pnpm-lock.yaml"],
+	yarn: ["yarn.lock"],
+	bun: ["bun.lock", "bun.lockb"]
+};
+const SCRIPTS = {
+	translate: "ai-translate sync",
+	"translate:check": "ai-translate check",
+	"translate:validate": "ai-translate validate"
+};
+const DEPENDENCY_FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"optionalDependencies"
+];
+function isFirstPartyPackage(name) {
+	return name === "ai-translate" || name.startsWith("@ai-translate/");
 }
-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"]
-	];
+/** Registry versions, ranges, and tags are refreshable. Paths, URLs, workspace
+* protocols, and aliases are intentional user choices and remain untouched. */
+function isRegistryVersion(version) {
+	return /^[a-z\d.*+~^<>=| _-]+$/iu.test(version.trim());
+}
+function installCommand(manager, packages, cwd, isWorkspaceRoot, field) {
+	const adding = packages.length > 0;
+	const saveFlag = field === void 0 ? void 0 : manager === "npm" || manager === "pnpm" ? {
+		dependencies: "--save-prod",
+		devDependencies: "--save-dev",
+		optionalDependencies: "--save-optional"
+	}[field] : {
+		dependencies: void 0,
+		devDependencies: "--dev",
+		optionalDependencies: "--optional"
+	}[field];
+	return {
+		command: manager,
+		args: [
+			manager === "npm" || !adding ? "install" : "add",
+			...saveFlag === void 0 ? [] : [saveFlag],
+			...manager === "pnpm" && adding && isWorkspaceRoot ? ["--workspace-root"] : [],
+			...manager === "yarn" ? [] : ["--ignore-scripts"],
+			...packages
+		],
+		cwd,
+		...manager === "yarn" ? { env: { YARN_ENABLE_SCRIPTS: "false" } } : {}
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseManifest(contents, manifestPath) {
+	let value;
 	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));
+		value = JSON.parse(contents);
 	} catch {
-		return expected;
+		throw new Error(`Invalid JSON in ${manifestPath}. Fix it before running init.`);
+	}
+	if (!isRecord(value)) throw new Error(`${manifestPath} must contain a JSON object.`);
+	for (const field of [
+		"dependencies",
+		"devDependencies",
+		"optionalDependencies",
+		"peerDependencies",
+		"scripts"
+	]) {
+		const entries = value[field];
+		if (entries !== void 0 && (!isRecord(entries) || Object.values(entries).some((entry) => typeof entry !== "string" || field !== "scripts" && entry.trim() === ""))) throw new Error(`${manifestPath}: ${field} must be an object of strings.`);
+	}
+	if (value.packageManager !== void 0 && typeof value.packageManager !== "string") throw new Error(`${manifestPath}: packageManager must be a string.`);
+	if (value.workspaces !== void 0) {
+		const patterns = isRecord(value.workspaces) ? value.workspaces.packages : value.workspaces;
+		if (!Array.isArray(patterns) || patterns.some((pattern) => typeof pattern !== "string" || pattern.trim() === "")) throw new Error(`${manifestPath}: workspaces must contain an array of package patterns.`);
+	}
+	return value;
+}
+async function readOptional(filePath) {
+	try {
+		return await promises.readFile(filePath, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+}
+async function exists(filePath) {
+	try {
+		await promises.lstat(filePath);
+		return true;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
 	}
 }
+/** Only literal lists establish membership; YAML aliases and expressions do not. */
+function pnpmWorkspacePatterns(contents) {
+	const lines = contents.split(/\r?\n/u);
+	const start = lines.findIndex((line) => /^packages\s*:/u.test(line));
+	if (start === -1) return;
+	const inline = lines[start]?.replace(/^packages\s*:\s*/u, "").trim() ?? "";
+	if (inline !== "" && !inline.startsWith("#")) try {
+		const parsed = JSON.parse(inline);
+		return Array.isArray(parsed) && parsed.every((value) => typeof value === "string") ? parsed : void 0;
+	} catch {
+		return;
+	}
+	const patterns = [];
+	for (const line of lines.slice(start + 1)) {
+		if (line.trim() === "" || line.trimStart().startsWith("#")) continue;
+		if (!/^(?:\s|-)/u.test(line)) break;
+		const item = line.match(/^\s*-\s+(.+?)\s*$/u)?.[1];
+		if (item === void 0) return;
+		const doubleQuoted = item.match(/^("(?:[^"\\]|\\.)*")\s*(?:#.*)?$/u)?.[1];
+		const singleQuoted = item.match(/^'((?:[^']|'')*)'\s*(?:#.*)?$/u)?.[1];
+		if (doubleQuoted !== void 0) try {
+			patterns.push(JSON.parse(doubleQuoted));
+		} catch {
+			return;
+		}
+		else if (singleQuoted !== void 0) patterns.push(singleQuoted.replaceAll("''", "'"));
+		else {
+			const plain = item.replace(/\s+#.*$/u, "");
+			if (/^[!*&@[{?]|[\s"'#:>|]/u.test(plain)) return;
+			patterns.push(plain);
+		}
+	}
+	return patterns;
+}
+function matchesWorkspace(relative, patterns) {
+	const normalized = relative.split(path.sep).join("/");
+	const matches = (pattern) => path.matchesGlob(normalized, pattern.replace(/^\.\//u, "").replace(/\/$/u, ""));
+	return patterns.some((pattern) => !pattern.startsWith("!") && matches(pattern)) && !patterns.some((pattern) => pattern.startsWith("!") && matches(pattern.slice(1)));
+}
+async function workspaceRoot(cwd, manifest) {
+	for (let directory = cwd;; directory = path.dirname(directory)) {
+		const text = directory === cwd ? void 0 : await readOptional(path.join(directory, "package.json"));
+		const candidate = directory === cwd ? manifest : text === void 0 ? {} : parseManifest(text, path.join(directory, "package.json"));
+		const pnpmWorkspace = await readOptional(path.join(directory, "pnpm-workspace.yaml"));
+		if (candidate.workspaces !== void 0 || pnpmWorkspace !== void 0) {
+			const declared = isRecord(candidate.workspaces) ? candidate.workspaces.packages : candidate.workspaces;
+			const patterns = pnpmWorkspace === void 0 ? declared : pnpmWorkspacePatterns(pnpmWorkspace);
+			return directory === cwd || patterns !== void 0 && matchesWorkspace(path.relative(directory, cwd), patterns) ? {
+				root: directory,
+				manifest: candidate
+			} : void 0;
+		}
+		if (path.dirname(directory) === directory || await exists(path.join(directory, ".git"))) return;
+	}
+}
+function managerFromDeclaration(value) {
+	if (value === void 0) return;
+	if (typeof value !== "string") throw new Error("The package manager must be npm, pnpm, yarn, or bun.");
+	const name = value.split("@")[0];
+	if (!MANAGERS.includes(name)) throw new Error(`Unsupported package manager ${value}. Use --package-manager npm, pnpm, yarn, or bun.`);
+	return name;
+}
+/** Reads project metadata only. Preview never executes a package manager or writes files. */
+async function planProjectSetup(cwd, packages, options = {}) {
+	for (const name of packages) if (name.length > 214 || !/^(?:@[a-z\d][a-z\d._-]*\/)?[a-z\d][a-z\d._-]*$/iu.test(name)) throw new Error(`Invalid dependency package name ${JSON.stringify(name)}.`);
+	const root = await promises.realpath(cwd);
+	const manifestPath = path.join(root, "package.json");
+	if (await exists(manifestPath)) {
+		if (!(await promises.lstat(manifestPath)).isFile()) throw new Error(`${manifestPath} must be a regular file, not a symlink or directory.`);
+	}
+	const originalManifest = await readOptional(manifestPath);
+	const manifest = originalManifest === void 0 ? { private: true } : parseManifest(originalManifest, manifestPath);
+	const workspace = await workspaceRoot(root, manifest);
+	let manager = managerFromDeclaration(options.packageManager ?? manifest.packageManager ?? workspace?.manifest.packageManager);
+	if (manager === void 0) {
+		const detected = /* @__PURE__ */ new Set();
+		for (let directory = root;; directory = path.dirname(directory)) {
+			for (const candidate of MANAGERS) for (const fileName of LOCKFILES[candidate]) if (await exists(path.join(directory, fileName))) detected.add(candidate);
+			if (directory === (workspace?.root ?? root)) break;
+		}
+		if (detected.size > 1) throw new Error(`Ambiguous package managers (${[...detected].join(", ")}). Pass --package-manager to choose.`);
+		manager = [...detected][0] ?? "npm";
+	}
+	const declared = new Set(DEPENDENCY_FIELDS.flatMap((field) => Object.keys(manifest[field] ?? {})));
+	const missing = [...new Set(packages)].filter((name) => !declared.has(name));
+	const grouped = {
+		dependencies: [],
+		devDependencies: [],
+		optionalDependencies: []
+	};
+	const notices = [];
+	for (const name of new Set(packages)) {
+		const fields = DEPENDENCY_FIELDS.filter((field) => Object.hasOwn(manifest[field] ?? {}, name));
+		if (!isFirstPartyPackage(name)) {
+			if (fields.length === 0) grouped.devDependencies.push(name);
+			continue;
+		}
+		if (fields.length > 1) throw new Error(`${name} is declared in multiple dependency sections (${fields.join(", ")}). Keep it in one section before running init so its dependency category can be preserved.`);
+		const field = fields[0] ?? "devDependencies";
+		const version = manifest[field]?.[name];
+		if (version !== void 0 && !isRegistryVersion(version)) {
+			notices.push(`Kept ${name}'s custom source in ${field}. Init cannot refresh it automatically; ensure it supports the generated configuration.`);
+			continue;
+		}
+		grouped[field].push(`${name}@latest`);
+		if (version !== void 0) notices.push(`Refresh ${name} to the latest release, keeping it in ${field}.`);
+	}
+	const scripts = { ...manifest.scripts };
+	let changed = originalManifest === void 0;
+	for (const [name, command] of Object.entries(SCRIPTS)) if (!Object.hasOwn(scripts, name)) {
+		scripts[name] = command;
+		changed = true;
+	}
+	const indent = originalManifest?.match(/\r?\n([\t ]+)"/u)?.[1] ?? "  ";
+	const newline = originalManifest?.includes("\r\n") === true ? "\r\n" : "\n";
+	const manifestContents = changed ? `${JSON.stringify({
+		...manifest,
+		scripts
+	}, null, indent).replaceAll("\n", newline)}${newline}` : void 0;
+	const installCommands = DEPENDENCY_FIELDS.filter((field) => grouped[field].length > 0).map((field) => installCommand(manager, grouped[field], root, workspace?.root === root, field));
+	if (installCommands.length === 0) installCommands.push(installCommand(manager, [], root, workspace?.root === root));
+	return {
+		packageManager: manager,
+		manifestPath,
+		manifestContents,
+		originalManifest,
+		packages: missing,
+		installCommands,
+		notices
+	};
+}
+const executeFile = promisify(execFile);
+/** Windows package-manager shims need cmd.exe. Only fixed manager names and
+* argument tokens generated by this module may enter its command string. */
+function packageManagerProcess(command, args, platform = process.platform) {
+	if (platform !== "win32" || command === "bun") return {
+		command,
+		args: [...args]
+	};
+	if (!MANAGERS.includes(command) || args.some((arg) => !/^[-@a-z\d._/]+$/iu.test(arg))) throw new Error("Unsafe Windows package-manager command or argument.");
+	return {
+		command: process.env.ComSpec ?? process.env.COMSPEC ?? "cmd.exe",
+		args: [
+			"/d",
+			"/s",
+			"/c",
+			`"${command} ${args.join(" ")}"`
+		],
+		windowsVerbatimArguments: true
+	};
+}
+const installProject = async (command, args, cwd, env) => {
+	let actualArgs = [...args];
+	let actualEnv = {
+		...process.env,
+		...env
+	};
+	if (command === "yarn") {
+		const probe = packageManagerProcess(command, ["--version"]);
+		const { stdout } = await executeFile(probe.command, probe.args, {
+			cwd,
+			timeout: 15e3,
+			...probe.windowsVerbatimArguments === void 0 ? {} : { windowsVerbatimArguments: probe.windowsVerbatimArguments }
+		});
+		const major = Number.parseInt(stdout.trim().split(".")[0] ?? "", 10);
+		if (!Number.isFinite(major) || major < 1) throw new Error("Unable to determine the installed Yarn version.");
+		if (major === 1) {
+			actualArgs = [
+				...actualArgs,
+				"--ignore-scripts",
+				...actualArgs[0] === "add" ? ["--ignore-workspace-root-check"] : []
+			];
+			actualEnv = { ...process.env };
+		}
+	}
+	await new Promise((resolve, reject) => {
+		const invocation = packageManagerProcess(command, actualArgs);
+		const child = spawn(invocation.command, invocation.args, {
+			cwd,
+			env: actualEnv,
+			shell: false,
+			stdio: "inherit",
+			...invocation.windowsVerbatimArguments === void 0 ? {} : { windowsVerbatimArguments: invocation.windowsVerbatimArguments }
+		});
+		child.once("error", reject);
+		child.once("exit", (code, signal) => {
+			if (code === 0) resolve();
+			else reject(/* @__PURE__ */ new Error(`${command} exited ${signal === null ? `with code ${String(code)}` : `after signal ${signal}`}.`));
+		});
+	});
+};
+/** Leaves successful setup edits in place if installing fails, so init can be retried. */
+async function applyProjectSetup(plan, options = {}) {
+	if (await readOptional(plan.manifestPath) !== plan.originalManifest) throw new Error(`${plan.manifestPath} changed during init. Run init again.`);
+	if (await exists(plan.manifestPath) && !(await promises.lstat(plan.manifestPath)).isFile()) throw new Error(`${plan.manifestPath} must be a regular file, not a symlink or directory.`);
+	const lines = [...plan.notices];
+	if (plan.manifestContents !== void 0) {
+		await promises.writeFile(plan.manifestPath, plan.manifestContents, {
+			encoding: "utf8",
+			flag: plan.originalManifest === void 0 ? "wx" : "w"
+		});
+		lines.push(`${plan.originalManifest === void 0 ? "Created" : "Updated"} package.json with translation scripts.`);
+	}
+	for (const { command, args, cwd, env } of plan.installCommands) {
+		if (options.install === false) {
+			if (command === "yarn") lines.push(`Install dependencies (Yarn 2+): YARN_ENABLE_SCRIPTS=false yarn ${args.join(" ")}`, `Install dependencies (Yarn 1): yarn ${args.join(" ")} --ignore-scripts${args[0] === "add" ? " --ignore-workspace-root-check" : ""}`);
+			else lines.push(`Install dependencies: ${command} ${args.join(" ")}`);
+			continue;
+		}
+		try {
+			await (options.installer ?? installProject)(command, args, cwd, env);
+		} catch (error) {
+			const detail = error instanceof Error ? error.message : String(error);
+			throw new Error(`Dependency installation failed: ${detail} Setup files were kept. Retry init to finish installing all required dependencies.`, { cause: error });
+		}
+	}
+	if (options.install !== false) lines.push(`Dependencies installed with ${plan.packageManager}; lifecycle scripts were disabled.`);
+	return lines;
+}
+//#endregion
+//#region src/init.ts
+const CONFIG_FILENAME = "ai-translate.config.ts";
+/** Detection and config plans stay independent of the installation workflow. */
+const builtinInitIntegrations = [
+	...builtinIntegrations,
+	appleIntegration,
+	expoIntegration
+];
+function catalogs(setup) {
+	return [setup.plan.catalog, ...setup.plan.additionalCatalogs ?? []];
+}
+function hasResources(setup) {
+	return catalogs(setup).some((catalog) => catalog.kind !== "adapter" || !Array.isArray(catalog.options.include) || catalog.options.include.length > 0);
+}
+function overlaps(left, right) {
+	if (left.kind === "adapter" || right.kind === "adapter") return left.kind === "adapter" && right.kind === "adapter" && left.factory.from === right.factory.from && left.factory.name === right.factory.name && left.options.rootDir === right.options.rootDir;
+	const a = path.resolve(left.rootDir);
+	const b = path.resolve(right.rootDir);
+	const leftFiles = left.kind === "document-json" && left.localeFiles !== void 0 ? Object.values(left.localeFiles).map((file) => path.resolve(a, file)) : void 0;
+	const rightFiles = right.kind === "document-json" && right.localeFiles !== void 0 ? Object.values(right.localeFiles).map((file) => path.resolve(b, file)) : void 0;
+	if (leftFiles !== void 0 && rightFiles !== void 0) return leftFiles.some((file) => rightFiles.includes(file));
+	if (leftFiles !== void 0) return leftFiles.some((file) => right.kind === "document-json" ? path.dirname(file) === b : file.startsWith(`${b}${path.sep}`));
+	if (rightFiles !== void 0) return rightFiles.some((file) => left.kind === "document-json" ? path.dirname(file) === a : file.startsWith(`${a}${path.sep}`));
+	return a === b || a.startsWith(`${b}${path.sep}`) || b.startsWith(`${a}${path.sep}`);
+}
 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.
-*/
+	const [best] = setups;
+	if (best === void 0) throw new Error("No supported localization setup was found. ai-translate init recognises next-intl and i18next, Expo locale mappings, Apple String Catalogs, localized .strings tables, and Xcode or Apple Swift package projects. For apps with hardcoded text, first externalize strings into localization resources. Run init from the project root; extraction and runtime wiring are described in docs/native-apps.md.");
+	const selected = [];
+	for (const candidate of setups.filter(hasResources)) {
+		const conflict = selected.find((other) => catalogs(other).some((left) => catalogs(candidate).some((right) => overlaps(left, right))));
+		if (conflict !== void 0) {
+			if (conflict.confidence === candidate.confidence) throw new Error(`Found overlapping localization setups (${conflict.integrationId}, ${candidate.integrationId}). Re-run with --integration <id> to choose.`);
+			continue;
+		}
+		selected.push(candidate);
+	}
+	if (selected.length < 2) return selected[0] ?? best;
+	if (selected.some((setup) => setup.plan.sourceLocale !== best.plan.sourceLocale)) throw new Error("Detected setups use different source locales. Run init with --integration <id> and use separate configs for each source locale.");
+	const targetLocales = resolveTargets(selected.flatMap((setup) => setup.plan.targetLocales), best.plan.sourceLocale);
+	const combined = selected.flatMap((setup) => catalogs(setup).map((catalog, index) => {
+		const id = `${setup.integrationId}-${String(index + 1)}`;
+		return catalog.kind === "adapter" ? {
+			...catalog,
+			options: {
+				...catalog.options,
+				id
+			}
+		} : {
+			...catalog,
+			id,
+			messageFormat: catalog.messageFormat ?? setup.plan.messageFormat
+		};
+	}));
+	return {
+		confidence: best.confidence,
+		displayName: selected.map((setup) => setup.displayName).join(" + "),
+		evidence: selected.flatMap((setup) => setup.evidence),
+		integrationId: selected.map((setup) => setup.integrationId).join("+"),
+		plan: {
+			...best.plan,
+			catalog: combined[0] ?? best.plan.catalog,
+			additionalCatalogs: combined.slice(1),
+			targetLocales,
+			warnings: selected.flatMap((setup) => setup.plan.warnings)
+		}
+	};
+}
+function resolveTargets(locales, source) {
+	const names = /* @__PURE__ */ new Map();
+	const sourceTag = Intl.getCanonicalLocales(source)[0];
+	for (const locale of locales) {
+		if (!isLocaleTag(locale)) throw new Error(`Invalid target locale ${JSON.stringify(locale)}.`);
+		const canonical = Intl.getCanonicalLocales(locale)[0] ?? locale;
+		if (canonical === sourceTag) throw new Error(`Target locale ${locale} is also the source locale.`);
+		const previous = names.get(canonical);
+		if (previous !== void 0 && previous !== locale) throw new Error(`Locale aliases ${previous} and ${locale} refer to the same language. Normalize the resource names before combining setups.`);
+		names.set(canonical, locale);
+	}
+	return [...names.values()];
+}
+async function readSetupFile(cwd, name) {
+	try {
+		const file = path.join(cwd, name);
+		const stat = await promises.lstat(file);
+		if (!stat.isFile() || stat.isSymbolicLink()) throw new Error(`${name} must be a regular file; init will not follow symbolic links.`);
+		return await promises.readFile(file, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+function appendLines(original, additions) {
+	const existing = original ?? "";
+	const missing = additions.filter((line) => !existing.split(/\r?\n/u).includes(line));
+	if (missing.length === 0) return existing;
+	const newline = existing.includes("\r\n") ? "\r\n" : "\n";
+	return `${existing}${existing.length > 0 && !existing.endsWith("\n") ? newline : ""}${missing.join(newline)}${newline}`;
+}
+function apiKeyVariable(options) {
+	if (options.provider !== "ai-sdk") return "OPENAI_API_KEY";
+	return {
+		"@ai-sdk/anthropic": "ANTHROPIC_API_KEY",
+		"@ai-sdk/google": "GOOGLE_GENERATIVE_AI_API_KEY",
+		"@ai-sdk/groq": "GROQ_API_KEY",
+		"@ai-sdk/mistral": "MISTRAL_API_KEY",
+		"@ai-sdk/openai": "OPENAI_API_KEY",
+		"@ai-sdk/xai": "XAI_API_KEY"
+	}[options.providerPackage ?? "@ai-sdk/openai"];
+}
+/** Detect, plan all changes, then install the generated config's direct dependencies. */
 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);
+	await readSetupFile(cwd, "package.json");
+	const setups = await detectProject(cwd, { integrations: options.integrations ?? builtinInitIntegrations });
+	const detected = chooseSetup(setups, options.integration);
+	const requestedLocales = options.locales === void 0 ? void 0 : resolveTargets(options.locales, detected.plan.sourceLocale).map((locale) => detected.plan.targetLocales.find((existing) => Intl.getCanonicalLocales(existing)[0] === Intl.getCanonicalLocales(locale)[0]) ?? locale);
+	const setup = requestedLocales === void 0 ? detected : {
+		...detected,
+		plan: {
+			...detected.plan,
+			targetLocales: requestedLocales
+		}
+	};
+	for (const catalog of catalogs(setup)) {
+		if (catalog.kind !== "document-json" || catalog.localeFiles === void 0) continue;
+		const missing = setup.plan.targetLocales.filter((locale) => !Object.hasOwn(catalog.localeFiles ?? {}, locale));
+		if (missing.length > 0) throw new Error(`Missing locale file mappings for ${missing.join(", ")}. Add them to the project's locale configuration (expo.locales for Expo), or use --locale to select only mapped languages.`);
+	}
+	const contents = renderConfig(setup.plan, options);
+	const lines = [
+		`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(", ")}`,
+		...setup.plan.warnings.map((warning) => `  ! ${warning}`)
+	];
+	const selectedIds = setup.integrationId.split("+");
+	const others = setups.filter((candidate) => !selectedIds.includes(candidate.integrationId));
 	if (others.length > 0) lines.push(`Also detected, not used: ${others.map((candidate) => candidate.displayName).join(", ")}.`);
+	const existing = [];
+	for (const name of CONFIG_CANDIDATES) {
+		const original = await readSetupFile(cwd, name);
+		if (original !== null) existing.push({
+			contents,
+			name,
+			original
+		});
+	}
+	if (existing.length > 1) throw new Error(`Multiple ai-translate configs exist: ${existing.map((file) => file.name).join(", ")}. Keep one config before running init.`);
+	const config = existing[0] ?? {
+		contents,
+		name: CONFIG_FILENAME,
+		original: null
+	};
+	if (config.original !== null && config.original !== contents && options.force !== true && options.preview !== true) throw new Error(`${config.name} already exists with different contents. Use --preview to review changes or --force to overwrite it.`);
+	const project = await planProjectSetup(cwd, requiredConfigPackages(setup.plan, options), options.packageManager === void 0 ? {} : { packageManager: options.packageManager });
+	const files = [config];
+	const ignore = await readSetupFile(cwd, ".gitignore");
+	files.push({
+		name: ".gitignore",
+		original: ignore,
+		contents: appendLines(ignore, [
+			"node_modules/",
+			".env.local",
+			".env.*.local"
+		])
+	});
+	const key = apiKeyVariable(options);
+	if (key !== void 0) {
+		const example = await readSetupFile(cwd, ".env.example");
+		const hasKey = example?.split(/\r?\n/u).some((line) => line.trimStart().startsWith(`${key}=`)) === true;
+		files.push({
+			name: ".env.example",
+			original: example,
+			contents: hasKey ? example : appendLines(example, [`${key}=`])
+		});
+	}
+	lines.push("", `Package manager: ${project.packageManager}.`);
 	if (options.preview === true) {
-		lines.push("", `Would write ${CONFIG_FILENAME}:`, "", contents);
+		lines.push(...project.notices);
+		for (const file of files) if (file.contents !== file.original || file === config) lines.push("", `Would write ${file.name}:`, "", file.name === ".env.example" ? `${key ?? "PROVIDER_API_KEY"}= (existing entries preserved)` : file.contents);
+		if (project.manifestContents !== void 0) lines.push("", "Would write package.json:", "", project.manifestContents);
+		for (const command of project.installCommands) lines.push("", `Would ${options.install === false ? "skip installation; run" : "install with"}: ${command.command} ${command.args.join(" ")}`);
 		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.`);
+	for (const file of files) {
+		if (file.contents === file.original) continue;
+		if (await readSetupFile(cwd, file.name) !== file.original) throw new Error(`${file.name} changed during init; rerun to review the current project.`);
+		await promises.writeFile(path.join(cwd, file.name), file.contents, {
+			encoding: "utf8",
+			flag: file.original === null ? "wx" : "w"
+		});
+		lines.push(`Wrote ${file.name}.`);
+	}
+	lines.push(...await applyProjectSetup(project, { install: options.install !== false }));
+	lines.push("", "Setup complete. Before translating:");
+	if (key !== void 0) lines.push(`  Set ${key} in your shell or .env.local; .env.example documents the variable.`);
+	else lines.push(`  Configure the credentials your ${options.providerPackage ?? "AI SDK"} provider reads.`);
+	if (setup.plan.targetLocales.length === 0) lines.push(`  Choose target languages in ${config.name}, or rerun init --locale fr --locale de --force.`);
+	if (!hasResources(setup)) lines.push("  Extract localization resources using the instructions above, then rerun init --force.");
+	lines.push("  Run npx ai-translate sync --dry-run to review the work, then npx ai-translate sync to translate.");
 	return {
-		configPath,
+		configPath: path.join(cwd, config.name),
 		lines,
 		setup
 	};
@@ -159,6 +615,7 @@ function cloneEntry(entry) {
 	return {
 		...entry,
 		address: entry.address.map((segment) => ({ ...segment })),
+		...entry.context === void 0 ? {} : { context: structuredClone(entry.context) },
 		...entry.meta === void 0 ? {} : { meta: { ...entry.meta } },
 		...entry.tokens === void 0 ? {} : { tokens: entry.tokens.map((token) => ({ ...token })) }
 	};
@@ -265,6 +722,12 @@ var StagedCatalogs = class {
 	async promote() {
 		for (const staged of this.files.values()) await writeFileAtomic(staged.realPath, await promises.readFile(staged.tempPath), staged.mode);
 	}
+	async verifyOriginals() {
+		await Promise.all([...this.files.values()].map(async (staged) => {
+			const current = await readOriginal(staged.realPath);
+			if (!(current.original === null ? staged.original === null : staged.original !== null && current.original.equals(staged.original)) || current.mode !== staged.mode) throw new Error(`Localization file changed during translation: ${staged.realPath}. No staged changes were committed; rerun with the updated file.`);
+		}));
+	}
 	async durableChanges() {
 		return Promise.all([...this.files.values()].map(async (staged) => ({
 			...staged.mode === void 0 ? {} : { mode: staged.mode },
@@ -344,7 +807,10 @@ var StagedCatalogs = class {
 		const mergeStagedState = catalog.mergeStagedState?.bind(catalog);
 		return {
 			createDocumentRef: (sourceRef, locale) => catalog.createDocumentRef(sourceRef, locale),
+			...catalog.createScaffoldDocument === void 0 ? {} : { createScaffoldDocument: catalog.createScaffoldDocument.bind(catalog) },
 			id: catalog.id,
+			...catalog.messageFormats === void 0 ? {} : { messageFormats: catalog.messageFormats },
+			...catalog.localizeSourceDocument === void 0 ? {} : { localizeSourceDocument: catalog.localizeSourceDocument.bind(catalog) },
 			listDocumentRefs: (sourceLocale) => catalog.listDocumentRefs(sourceLocale),
 			loadDocument: (ref) => this.loadStaged(catalog, ref),
 			...mergeStagedState === void 0 ? {} : { mergeStagedState },
@@ -385,11 +851,24 @@ var StagedCatalogs = class {
 				skippedDocuments += 1;
 				continue;
 			}
-			await adapter.writeDocument(await adapter.reconcileDocument({
+			const localizedSource = adapter.createScaffoldDocument !== void 0 || adapter.localizeSourceDocument === void 0 ? source : await adapter.localizeSourceDocument({
+				locale: options.locale,
+				source
+			});
+			const scaffold = adapter.createScaffoldDocument === void 0 ? await adapter.reconcileDocument({
 				ref: targetRef,
-				source,
+				source: localizedSource,
 				target: null
-			}));
+			}) : await adapter.createScaffoldDocument({
+				ref: targetRef,
+				source: localizedSource,
+				strategy
+			});
+			if (scaffold === null) {
+				skippedDocuments += 1;
+				continue;
+			}
+			await adapter.writeDocument(scaffold);
 			createdDocuments += 1;
 		}
 		return {
@@ -425,6 +904,7 @@ async function runStagedCatalogTransaction(config, operation, shouldCommit = ()
 		try {
 			const result = await operation(stagedConfig);
 			if (!shouldCommit(result)) return result;
+			await stagedCatalogs.verifyOriginals();
 			const durableStore = durableStateStore(config.state);
 			if (durableStore !== null) {
 				const documents = await stagedCatalogs.durableChanges();
@@ -473,6 +953,10 @@ function requireProviderChoice(value) {
 	if (value !== "ai-sdk" && value !== "openai") throw new Error(`Option "--provider" accepts "openai" or "ai-sdk", not "${value}".`);
 	return value;
 }
+function requirePackageManager(value) {
+	if (value !== "npm" && value !== "pnpm" && value !== "yarn" && value !== "bun") throw new Error("Option \"--package-manager\" accepts npm, pnpm, yarn, or bun.");
+	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;
@@ -626,7 +1110,7 @@ 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 init [--locale <locale>] [--integration <id>] [--provider <openai|ai-sdk>] [--provider-package <@ai-sdk/...>] [--model <id>] [--package-manager <npm|pnpm|yarn|bun>] [--no-install] [--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>]
@@ -659,6 +1143,13 @@ function parseCommand(argv) {
 			if (flag.length === 0) throw new Error("Encountered an empty option flag.");
 			const nextValue = inlineValue ?? argv[index + 1];
 			switch (flag) {
+				case "no-install":
+					options.install = false;
+					break;
+				case "package-manager":
+					options.packageManager = requireOptionValue(flag, nextValue);
+					if (inlineValue === void 0) index += 1;
+					break;
 				case "check":
 					options.auditCheck = true;
 					break;
@@ -758,20 +1249,34 @@ async function runCli(argv = process.argv.slice(2), cwd = process.cwd()) {
 			return 0;
 		}
 		if (parsed.command === "version") {
-			console.log("0.0.0");
+			const manifest = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+			console.log(manifest.version);
 			return 0;
 		}
 		switch (parsed.command) {
 			case "init": {
 				const result = await runInit(cwd, {
 					force: parsed.options.force === true,
+					install: parsed.options.install !== false,
 					...parsed.options.integration === void 0 ? {} : { integration: parsed.options.integration },
 					...parsed.options.model === void 0 ? {} : { model: parsed.options.model },
+					...parsed.options.locales === void 0 ? {} : { locales: parsed.options.locales },
+					...parsed.options.packageManager === void 0 ? {} : { packageManager: requirePackageManager(parsed.options.packageManager) },
 					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"));
+				if (result.configPath !== null && parsed.options.install !== false) {
+					await loadEnvFiles(cwd);
+					const { config, configPath } = await loadConfig(cwd, result.configPath);
+					const validation = await validateConfig(config, configPath, { locales: [] });
+					if (validation.issues.filter((issue) => issue.severity === "error").length > 0) {
+						console.error(JSON.stringify(validation, null, 2));
+						throw new Error("Setup files were created, but localization validation failed. Fix the reported resources and run npx ai-translate validate.");
+					}
+					console.log("Generated configuration and source resources validated.");
+				}
 				return 0;
 			}
 			case "validate": {
@@ -944,4 +1449,4 @@ async function runCli(argv = process.argv.slice(2), cwd = process.cwd()) {
 //#endregion
 export { loadEnvFiles as a, loadConfig as i, runCli as n, findConfigPath as r, defineConfig$1 as t };
 
-//# sourceMappingURL=src-Cnnq284f.mjs.map
+//# sourceMappingURL=src-SwBEpdIU.mjs.map