@lingo.dev/cli 1.0.1 → 1.0.3

package/dist/renderer-D2iDOMA6.js

@@ -0,0 +1,1533 @@
+import { C as discoverLocales, S as writeLocaleFile, T as tryReadFile, _ as runExtractionPipeline, b as mergeEntries, c as formatCheckResult, d as computeSourceStatus, f as formatStatusTable, g as generateTypes, h as toApiPayload, l as runChecks, m as planLocalization, n as UpdateService, p as applyTranslations, s as VERSION, t as UpdateError, u as computeLocaleStatus, v as toLocaleEntries, w as findSourceFiles, x as readLocaleFile, y as getActiveEntries } from "./update-RHUBOb93.js";
+import { Args, CliConfig, Command, Options } from "@effect/cli";
+import { Console, Context, Data, Effect, Layer, Option, pipe } from "effect";
+import pc from "picocolors";
+import * as fs$1 from "node:fs/promises";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import { createClient } from "@supabase/supabase-js";
+import cfonts from "cfonts";
+import logUpdate from "log-update";
+import * as clack from "@clack/prompts";
+import { spawn } from "node:child_process";
+import * as ci from "ci-info";
+import * as crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+//#region src/services/cli-options.ts
+/**
+* Shared CLI option definitions used across extract, localize, status, and ship commands.
+*/
+const sourceLocaleOption = Options.text("source-locale").pipe(Options.withDescription("Source locale code"), Options.withDefault("en"));
+const targetLocaleOption = pipe(Options.text("target-locale"), Options.withDescription("Target locale(s) to localize"), Options.repeated);
+const srcOption = Options.text("src").pipe(Options.withDescription("Source directory to scan"), Options.withDefault("src"));
+const outOption = Options.text("out").pipe(Options.withDescription("Output directory for locale files"), Options.withDefault("locales"));
+const jsonOption = Options.boolean("json").pipe(Options.withDescription("Machine-readable JSON output for CI"));
+//#endregion
+//#region src/commands/extract.ts
+const check = Options.boolean("check").pipe(Options.withDescription("Check if JSONC is up to date (CI gate)"));
+const types = Options.text("types").pipe(Options.withDescription("Output path for generated type declarations"), Options.withDefault("lingo.d.ts"));
+const extractCommand = Command.make("extract", {
+	check,
+	src: srcOption,
+	sourceLocale: sourceLocaleOption,
+	out: outOption,
+	types
+}, ({ check, src, sourceLocale, out, types: typesOut }) => Effect.gen(function* () {
+	const cwd = process.cwd();
+	const srcDir = path.resolve(cwd, src);
+	const outDir = path.resolve(cwd, out);
+	const localePath = path.join(outDir, `${sourceLocale}.jsonc`);
+	const typesPath = path.resolve(cwd, typesOut);
+	const filePaths = yield* Effect.tryPromise(() => findSourceFiles(srcDir));
+	if (filePaths.length === 0) {
+		yield* Console.log(`No .ts/.tsx files found in ${src}/`);
+		return;
+	}
+	const { messages, warnings, collisions } = runExtractionPipeline(yield* Effect.tryPromise(() => Promise.all(filePaths.map(async (f) => ({
+		code: await fs$1.readFile(f, "utf-8"),
+		filePath: path.relative(cwd, f)
+	})))));
+	for (const w of warnings) yield* Console.log(`  warn: ${w.src} - ${w.message}`);
+	if (collisions.length > 0) {
+		for (const c of collisions) {
+			yield* Console.error(`  collision: key "${c.key}" ->`);
+			for (const e of c.entries) yield* Console.error(`    "${e.source}" at ${e.src}`);
+		}
+		return yield* Effect.die(/* @__PURE__ */ new Error(`${collisions.length} hash collision(s) detected. Add context strings to disambiguate.`));
+	}
+	const entries = toLocaleEntries(messages);
+	const existingContent = yield* Effect.tryPromise(() => tryReadFile(localePath));
+	const existing = existingContent ? readLocaleFile(existingContent) : { entries: [] };
+	const merged = mergeEntries(existing, entries);
+	const jsonc = writeLocaleFile(merged);
+	const typesContent = generateTypes(merged);
+	if (check) {
+		const currentJsonc = existingContent ?? "";
+		const currentTypes = (yield* Effect.tryPromise(() => tryReadFile(typesPath))) ?? "";
+		if (jsonc !== currentJsonc || typesContent !== currentTypes) {
+			yield* Console.error("JSONC is stale. Run `lingo extract` to update.");
+			return yield* Effect.die(/* @__PURE__ */ new Error("Stale JSONC"));
+		}
+		yield* Console.log("Up to date.");
+		return;
+	}
+	yield* Effect.tryPromise(() => fs$1.mkdir(outDir, { recursive: true }));
+	yield* Effect.tryPromise(() => fs$1.writeFile(localePath, jsonc));
+	yield* Effect.tryPromise(() => fs$1.writeFile(typesPath, typesContent));
+	const newCount = entries.filter((e) => !existing.entries.some((ex) => ex.key === e.key)).length;
+	const orphanCount = merged.entries.filter((e) => e.metadata.orphan).length;
+	yield* Console.log(`Extracted ${messages.length} strings (${newCount} new, ${orphanCount} orphaned) -> ${path.relative(cwd, localePath)}`);
+})).pipe(Command.withDescription("Extract translatable strings from source files"));
+//#endregion
+//#region src/services/supabase.ts
+const supabase = createClient(process.env.LINGO_SUPABASE_URL ?? "https://nlugbbdqxnqwhydszieg.supabase.co", process.env.LINGO_SUPABASE_ANON_KEY ?? "sb_publishable_ZZH1cgFbkmb7Y0H482RFmA_jsvBxc3e", { auth: {
+	persistSession: false,
+	autoRefreshToken: false
+} });
+const sendOtp = (email) => Effect.tryPromise({
+	try: async () => {
+		const { error } = await supabase.auth.signInWithOtp({
+			email,
+			options: { shouldCreateUser: true }
+		});
+		if (error) throw error;
+	},
+	catch: (e) => new SupabaseError({
+		cause: e,
+		message: `Failed to send code to ${email}. Check the email address and try again.`
+	})
+});
+const verifyOtp = (email, code) => Effect.tryPromise({
+	try: async () => {
+		const { data, error } = await supabase.auth.verifyOtp({
+			email,
+			token: code,
+			type: "email"
+		});
+		if (error) throw error;
+		if (!data.session) throw new Error("No session returned");
+		return data.session;
+	},
+	catch: (e) => new SupabaseError({
+		cause: e,
+		message: "Invalid or expired code. Run lingo login to try again."
+	})
+});
+const refreshSession = (refreshToken) => Effect.tryPromise({
+	try: async () => {
+		const { data, error } = await supabase.auth.refreshSession({ refresh_token: refreshToken });
+		if (error) throw error;
+		if (!data.session) throw new Error("No session returned");
+		return data.session;
+	},
+	catch: (e) => new SupabaseError({
+		cause: e,
+		message: "Session expired"
+	})
+});
+var SupabaseError = class extends Data.TaggedError("SupabaseError") {};
+//#endregion
+//#region src/services/auth.ts
+var AuthError = class extends Data.TaggedError("AuthError") {};
+var AuthContext = class extends Context.Tag("AuthContext")() {};
+var AuthService = class extends Context.Tag("AuthService")() {};
+function credentialsPaths(homeDir) {
+	const dir = path.join(homeDir ?? os.homedir(), ".lingo");
+	return {
+		dir,
+		file: path.join(dir, "credentials.json")
+	};
+}
+const AuthServiceLive = Layer.effect(AuthService, pipe(Effect.context(), Effect.map((ctx) => {
+	const authCtx = Context.get(ctx, AuthContext);
+	const { dir: credsDir, file: credsFile } = credentialsPaths(authCtx.homeDir);
+	const readFile = () => {
+		try {
+			return JSON.parse(fs.readFileSync(credsFile, "utf-8"));
+		} catch {
+			return null;
+		}
+	};
+	const writeFile = (creds) => {
+		fs.mkdirSync(credsDir, {
+			recursive: true,
+			mode: 448
+		});
+		fs.writeFileSync(credsFile, JSON.stringify(creds, null, 2), { mode: 384 });
+	};
+	const deleteFile = () => {
+		try {
+			fs.unlinkSync(credsFile);
+		} catch {}
+	};
+	const resolve = Effect.gen(function* () {
+		if (authCtx.apiKeyFlag) return {
+			type: "api-key",
+			apiKey: authCtx.apiKeyFlag
+		};
+		const envKey = process.env.LINGO_API_KEY;
+		if (envKey) return {
+			type: "api-key",
+			apiKey: envKey
+		};
+		const stored = readFile();
+		if (!stored) return yield* Effect.fail(new AuthError({ message: "Not authenticated. Run lingo login to get started." }));
+		return stored;
+	});
+	const store = (creds) => Effect.try({
+		try: () => writeFile(creds),
+		catch: (e) => new AuthError({ message: `Failed to save credentials: ${e}` })
+	});
+	return {
+		resolve,
+		store,
+		clear: Effect.sync(() => deleteFile()),
+		ensureFresh: Effect.gen(function* () {
+			const creds = yield* resolve;
+			if (creds.type === "api-key") return creds;
+			const now = Math.floor(Date.now() / 1e3);
+			if (creds.expiresAt > now + 60) return creds;
+			const session = yield* pipe(refreshSession(creds.refreshToken), Effect.mapError(() => new AuthError({ message: "Session expired. Run lingo login to get started." })));
+			const refreshed = {
+				type: "session",
+				email: session.user.email ?? creds.email,
+				accessToken: session.access_token,
+				refreshToken: session.refresh_token,
+				expiresAt: session.expires_at ?? now + session.expires_in
+			};
+			yield* store(refreshed);
+			return refreshed;
+		})
+	};
+})));
+//#endregion
+//#region src/services/api-client.ts
+const BASE_URL = process.env.LINGO_API_URL ?? "https://api.lingo.dev";
+var ApiError = class extends Data.TaggedError("ApiError") {};
+var ApiClient = class extends Context.Tag("ApiClient")() {};
+function authHeaders(creds) {
+	if (creds.type === "session") return { Authorization: `Bearer ${creds.accessToken}` };
+	return { "X-API-Key": creds.apiKey };
+}
+function request(method, path, creds, body) {
+	return Effect.tryPromise({
+		try: async () => {
+			const res = await fetch(`${BASE_URL}${path}`, {
+				method,
+				headers: {
+					"Content-Type": "application/json",
+					...authHeaders(creds)
+				},
+				body: body ? JSON.stringify(body) : void 0
+			});
+			if (!res.ok) {
+				const text = await res.text().catch(() => "");
+				throw new Error(`${res.status}: ${text}`);
+			}
+			return await res.json();
+		},
+		catch: (e) => new ApiError({ message: e instanceof Error ? e.message : String(e) })
+	});
+}
+const ApiClientLive = Layer.effect(ApiClient, Effect.map(AuthService, (auth) => {
+	const withAuth = (fn) => pipe(auth.ensureFresh, Effect.flatMap(fn));
+	return {
+		listMemberships: withAuth((creds) => request("GET", "/users/me/memberships", creds)),
+		createOrganization: (name) => withAuth((creds) => request("POST", "/organizations", creds, { name })),
+		listEngines: (orgId) => withAuth((creds) => request("GET", `/organizations/${orgId}/engines`, creds)),
+		createEngine: (orgId, name) => withAuth((creds) => request("POST", "/engines", creds, {
+			ownerOrganizationId: orgId,
+			name
+		})),
+		getMe: withAuth((creds) => request("GET", "/users/me", creds)),
+		updateMe: (payload) => withAuth((creds) => request("PATCH", "/users/me", creds, payload)),
+		localize: (params) => withAuth((creds) => request("POST", "/process/localize", creds, params))
+	};
+}));
+//#endregion
+//#region src/services/config.ts
+var ConfigError = class extends Data.TaggedError("ConfigError") {};
+var ConfigService = class extends Context.Tag("ConfigService")() {};
+const CONFIG_DIR = ".lingo";
+const CONFIG_FILE = "config.json";
+const HOME = os.homedir();
+function findConfigPath(startDir) {
+	let dir = path.resolve(startDir);
+	while (true) {
+		const candidate = path.join(dir, CONFIG_DIR, CONFIG_FILE);
+		try {
+			fs.accessSync(candidate, fs.constants.R_OK);
+			return candidate;
+		} catch {}
+		const parent = path.dirname(dir);
+		if (parent === dir || dir === HOME) return null;
+		dir = parent;
+	}
+}
+function readConfigAt(filePath) {
+	try {
+		const content = fs.readFileSync(filePath, "utf-8");
+		const parsed = JSON.parse(content);
+		if (parsed.orgId && parsed.engineId) return parsed;
+		return null;
+	} catch {
+		return null;
+	}
+}
+const ConfigServiceLive = Layer.succeed(ConfigService, {
+	resolve: Effect.sync(() => {
+		const configPath = findConfigPath(process.cwd());
+		if (!configPath) return null;
+		return readConfigAt(configPath);
+	}),
+	store: (config) => Effect.try({
+		try: () => {
+			const dir = path.join(process.cwd(), CONFIG_DIR);
+			fs.mkdirSync(dir, { recursive: true });
+			fs.writeFileSync(path.join(dir, CONFIG_FILE), JSON.stringify(config, null, 2) + "\n");
+		},
+		catch: (e) => new ConfigError({ message: `Failed to save config: ${e}` })
+	}),
+	clear: Effect.sync(() => {
+		try {
+			fs.unlinkSync(path.join(process.cwd(), CONFIG_DIR, CONFIG_FILE));
+		} catch {}
+	}),
+	resolvedPath: Effect.sync(() => findConfigPath(process.cwd()))
+});
+//#endregion
+//#region src/commands/localize.ts
+const dryRun = Options.boolean("dry-run").pipe(Options.withDescription("Show what would change without writing"));
+const localizeCommand = Command.make("localize", {
+	sourceLocale: sourceLocaleOption,
+	targetLocale: targetLocaleOption,
+	out: outOption,
+	dryRun
+}, ({ sourceLocale, targetLocale: targetLocaleChunk, out, dryRun }) => Effect.gen(function* () {
+	const api = yield* ApiClient;
+	const config = yield* ConfigService;
+	const targetLocales = [...targetLocaleChunk];
+	if (targetLocales.length === 0) {
+		yield* Console.error("No target locales specified. Use --target-locale (e.g., --target-locale es --target-locale fr).");
+		return;
+	}
+	const cwd = process.cwd();
+	const outDir = path.resolve(cwd, out);
+	const sourcePath = path.join(outDir, `${sourceLocale}.jsonc`);
+	const sourceContent = yield* Effect.tryPromise(() => tryReadFile(sourcePath));
+	if (!sourceContent) {
+		yield* Console.error(`No source locale file at ${out}/${sourceLocale}.jsonc. Run \`lingo extract\` first.`);
+		return yield* Effect.die(/* @__PURE__ */ new Error(`Missing ${out}/${sourceLocale}.jsonc`));
+	}
+	const sourceFile = readLocaleFile(sourceContent);
+	const projectConfig = yield* config.resolve;
+	let totalNew = 0;
+	const failedLocales = [];
+	for (const locale of targetLocales) {
+		const targetPath = path.join(outDir, `${locale}.jsonc`);
+		const targetContent = yield* Effect.tryPromise(() => tryReadFile(targetPath));
+		const targetFile = targetContent ? readLocaleFile(targetContent) : { entries: [] };
+		const plan = planLocalization(sourceFile, targetFile, locale);
+		if (plan.missing.length === 0) {
+			yield* Console.log(`  ${locale}: up to date (${plan.existing} strings)`);
+			continue;
+		}
+		if (dryRun) {
+			yield* Console.log(`  ${locale}: ${plan.missing.length} strings to localize (dry run)`);
+			totalNew += plan.missing.length;
+			continue;
+		}
+		const { data, hints } = toApiPayload(plan.missing);
+		const result = yield* pipe(api.localize({
+			sourceLocale,
+			targetLocale: locale,
+			data,
+			hints,
+			engineId: projectConfig?.engineId,
+			triggerType: "cli"
+		}), Effect.catchAll((e) => Effect.gen(function* () {
+			yield* Console.error(`  ${locale}: failed - ${e.message}`);
+			failedLocales.push(locale);
+			return null;
+		})));
+		if (!result) continue;
+		const translated = applyTranslations(plan.missing, result.data);
+		const merged = mergeEntries(targetFile, [...getActiveEntries(targetFile.entries), ...translated]);
+		yield* Effect.tryPromise(() => fs$1.mkdir(outDir, { recursive: true }));
+		yield* Effect.tryPromise(() => fs$1.writeFile(targetPath, writeLocaleFile(merged)));
+		totalNew += plan.missing.length;
+		yield* Console.log(`  ${locale}: ${plan.missing.length} localized (${plan.existing + plan.missing.length} total)`);
+	}
+	if (dryRun) yield* Console.log(`\nDry run: ${totalNew} strings would be localized across ${targetLocales.length} locale(s).`);
+	else if (totalNew > 0 || failedLocales.length > 0) {
+		yield* Console.log(`\nLocalized ${totalNew} strings across ${targetLocales.length} locale(s).`);
+		if (failedLocales.length > 0) yield* Console.error(`Failed: ${failedLocales.join(", ")}`);
+	}
+})).pipe(Command.withDescription("Localize missing strings to target locales"));
+//#endregion
+//#region src/commands/ship.ts
+const shipCommand = Command.make("ship", {
+	sourceLocale: sourceLocaleOption,
+	targetLocale: targetLocaleOption,
+	src: srcOption,
+	out: outOption,
+	json: jsonOption
+}, ({ sourceLocale, targetLocale: targetLocaleChunk, src, out, json }) => Effect.gen(function* () {
+	const api = yield* ApiClient;
+	const projectConfig = yield* (yield* ConfigService).resolve;
+	const targetLocales = [...targetLocaleChunk];
+	const cwd = process.cwd();
+	const srcDir = path.resolve(cwd, src);
+	const outDir = path.resolve(cwd, out);
+	const localePath = path.join(outDir, `${sourceLocale}.jsonc`);
+	const typesPath = path.resolve(cwd, "lingo.d.ts");
+	if (!json) yield* Console.log("Extracting...");
+	const filePaths = yield* Effect.tryPromise(() => findSourceFiles(srcDir));
+	if (filePaths.length === 0) {
+		yield* Console.error(`No .ts/.tsx files found in ${src}/`);
+		return yield* Effect.die(/* @__PURE__ */ new Error(`No source files in ${src}/`));
+	}
+	const { messages, warnings, collisions } = runExtractionPipeline(yield* Effect.tryPromise(() => Promise.all(filePaths.map(async (f) => ({
+		code: await fs$1.readFile(f, "utf-8"),
+		filePath: path.relative(cwd, f)
+	})))));
+	if (!json) for (const w of warnings) yield* Console.log(`  warn: ${w.src} - ${w.message}`);
+	if (collisions.length > 0) {
+		for (const c of collisions) {
+			yield* Console.error(`  collision: key "${c.key}" ->`);
+			for (const e of c.entries) yield* Console.error(`    "${e.source}" at ${e.src}`);
+		}
+		return yield* Effect.die(/* @__PURE__ */ new Error(`${collisions.length} hash collision(s) detected.`));
+	}
+	const entries = toLocaleEntries(messages);
+	const existingContent = yield* Effect.tryPromise(() => tryReadFile(localePath));
+	const existing = existingContent ? readLocaleFile(existingContent) : { entries: [] };
+	const merged = mergeEntries(existing, entries);
+	yield* Effect.tryPromise(() => fs$1.mkdir(outDir, { recursive: true }));
+	yield* Effect.tryPromise(() => fs$1.writeFile(localePath, writeLocaleFile(merged)));
+	yield* Effect.tryPromise(() => fs$1.writeFile(typesPath, generateTypes(merged)));
+	if (!json) {
+		const newCount = entries.filter((e) => !existing.entries.some((ex) => ex.key === e.key)).length;
+		yield* Console.log(`  ${messages.length} strings extracted (${newCount} new)`);
+	}
+	let totalLocalized = 0;
+	const failedLocales = [];
+	if (targetLocales.length > 0) {
+		if (!json) yield* Console.log("Localizing...");
+		const sourceFile = readLocaleFile(yield* Effect.tryPromise(() => fs$1.readFile(localePath, "utf-8")));
+		for (const locale of targetLocales) {
+			const targetPath = path.join(outDir, `${locale}.jsonc`);
+			const targetContent = yield* Effect.tryPromise(() => tryReadFile(targetPath));
+			const targetFile = targetContent ? readLocaleFile(targetContent) : { entries: [] };
+			const plan = planLocalization(sourceFile, targetFile, locale);
+			if (plan.missing.length === 0) {
+				if (!json) yield* Console.log(`  ${locale}: up to date`);
+				continue;
+			}
+			const { data, hints } = toApiPayload(plan.missing);
+			const result = yield* pipe(api.localize({
+				sourceLocale,
+				targetLocale: locale,
+				data,
+				hints,
+				engineId: projectConfig?.engineId,
+				triggerType: "cli"
+			}), Effect.catchAll((e) => Effect.gen(function* () {
+				yield* Console.error(`  ${locale}: failed - ${e.message}`);
+				failedLocales.push(locale);
+				return null;
+			})));
+			if (!result) continue;
+			const translated = applyTranslations(plan.missing, result.data);
+			const mergedTarget = mergeEntries(targetFile, [...getActiveEntries(targetFile.entries), ...translated]);
+			yield* Effect.tryPromise(() => fs$1.writeFile(targetPath, writeLocaleFile(mergedTarget)));
+			totalLocalized += plan.missing.length;
+			if (!json) yield* Console.log(`  ${locale}: ${plan.missing.length} strings localized`);
+		}
+	}
+	const sourceFile = readLocaleFile(yield* Effect.tryPromise(() => fs$1.readFile(localePath, "utf-8")));
+	const statuses = [computeSourceStatus(sourceFile, sourceLocale)];
+	for (const locale of targetLocales) {
+		const content = yield* Effect.tryPromise(() => tryReadFile(path.join(outDir, `${locale}.jsonc`)));
+		const targetFile = content ? readLocaleFile(content) : { entries: [] };
+		statuses.push(computeLocaleStatus(sourceFile, targetFile, locale));
+	}
+	if (json) yield* Console.log(JSON.stringify({
+		extracted: messages.length,
+		localized: totalLocalized,
+		...failedLocales.length > 0 ? { failed: failedLocales } : {},
+		statuses
+	}, null, 2));
+	else {
+		yield* Console.log("");
+		yield* Console.log(formatStatusTable(statuses));
+		if (statuses.reduce((sum, s) => sum + s.missing, 0) === 0 && totalLocalized === 0) yield* Console.log("\nAll locales up to date. Nothing to do.");
+	}
+})).pipe(Command.withDescription("Extract, localize, and report status (idempotent pipeline)"));
+//#endregion
+//#region src/commands/status.ts
+const statusCommand = Command.make("status", {
+	json: jsonOption,
+	sourceLocale: sourceLocaleOption,
+	out: outOption
+}, ({ json, sourceLocale, out }) => Effect.gen(function* () {
+	const cwd = process.cwd();
+	const outDir = path.resolve(cwd, out);
+	const sourcePath = path.join(outDir, `${sourceLocale}.jsonc`);
+	const sourceContent = yield* Effect.tryPromise(() => tryReadFile(sourcePath));
+	if (!sourceContent) {
+		yield* Console.error(`No source locale file at ${out}/${sourceLocale}.jsonc. Run \`lingo extract\` first.`);
+		return yield* Effect.die(/* @__PURE__ */ new Error(`Missing ${out}/${sourceLocale}.jsonc`));
+	}
+	const sourceFile = readLocaleFile(sourceContent);
+	const targetLocales = yield* Effect.tryPromise(() => discoverLocales(outDir, sourceLocale));
+	const statuses = [computeSourceStatus(sourceFile, sourceLocale)];
+	for (const locale of targetLocales) {
+		const content = yield* Effect.tryPromise(() => tryReadFile(path.join(outDir, `${locale}.jsonc`)));
+		const targetFile = content ? readLocaleFile(content) : { entries: [] };
+		statuses.push(computeLocaleStatus(sourceFile, targetFile, locale));
+	}
+	if (json) yield* Console.log(JSON.stringify(statuses, null, 2));
+	else yield* Console.log(formatStatusTable(statuses));
+	const totalMissing = statuses.reduce((sum, s) => sum + s.missing, 0);
+	if (totalMissing > 0) return yield* Effect.die(/* @__PURE__ */ new Error(`${totalMissing} missing translation(s) across ${statuses.length} locale(s)`));
+})).pipe(Command.withDescription("Show per-locale translation completeness"));
+//#endregion
+//#region src/commands/check.ts
+const checkCommand = Command.make("check", {
+	json: jsonOption,
+	src: srcOption,
+	sourceLocale: sourceLocaleOption,
+	out: outOption
+}, ({ json, src, sourceLocale, out }) => Effect.gen(function* () {
+	const cwd = process.cwd();
+	const srcDir = path.resolve(cwd, src);
+	const outDir = path.resolve(cwd, out);
+	const localePath = path.join(outDir, `${sourceLocale}.jsonc`);
+	const typesPath = path.resolve(cwd, "lingo.d.ts");
+	const filePaths = yield* Effect.tryPromise(() => findSourceFiles(srcDir));
+	const { messages, warnings } = runExtractionPipeline(yield* Effect.tryPromise(() => Promise.all(filePaths.map(async (f) => ({
+		code: await fs$1.readFile(f, "utf-8"),
+		filePath: path.relative(cwd, f)
+	})))));
+	const entries = toLocaleEntries(messages);
+	const existingJsoncContent = (yield* Effect.tryPromise(() => tryReadFile(localePath))) ?? "";
+	const merged = mergeEntries(existingJsoncContent ? readLocaleFile(existingJsoncContent) : { entries: [] }, entries);
+	const generatedJsonc = writeLocaleFile(merged);
+	const generatedTypes = generateTypes(merged);
+	const existingTypes = (yield* Effect.tryPromise(() => tryReadFile(typesPath))) ?? "";
+	const targetLocales = yield* Effect.tryPromise(() => discoverLocales(outDir, sourceLocale).catch(() => []));
+	const targetFiles = yield* Effect.tryPromise(() => Promise.all(targetLocales.map(async (locale) => {
+		const content = await tryReadFile(path.join(outDir, `${locale}.jsonc`));
+		return {
+			locale,
+			file: content ? readLocaleFile(content) : { entries: [] }
+		};
+	})));
+	const result = runChecks({
+		warnings,
+		messageCount: messages.length,
+		generatedJsonc,
+		existingJsonc: existingJsoncContent,
+		generatedTypes,
+		existingTypes,
+		sourceFile: merged,
+		targetFiles
+	});
+	if (json) yield* Console.log(JSON.stringify(result, null, 2));
+	else yield* Console.log(formatCheckResult(result));
+	if (result.issues.length > 0) return yield* Effect.die(/* @__PURE__ */ new Error(`${result.issues.length} issue(s) found`));
+})).pipe(Command.withDescription("Verify i18n consistency: context, translations, types"));
+//#endregion
+//#region src/commands/guide.ts
+const allowedGuides = new Set([
+	"index",
+	"setup",
+	"api",
+	"migrate"
+]);
+const guideArg = pipe(Args.text({ name: "guide" }), Args.withDescription("Guide name"), Args.withDefault("index"));
+async function resolveGuidesDir() {
+	const here = path.dirname(new URL(import.meta.url).pathname);
+	const candidates = [path.resolve(here, "..", "..", "guides"), path.resolve(here, "..", "guides")];
+	for (const candidate of candidates) try {
+		if ((await fs$1.stat(candidate)).isDirectory()) return candidate;
+	} catch {}
+	throw new Error("guides directory not found in package");
+}
+async function readGuide(name) {
+	const guidesDir = await resolveGuidesDir();
+	const file = path.join(guidesDir, `${name}.md`);
+	return fs$1.readFile(file, "utf8");
+}
+const guideCommand = Command.make("guide", { guide: guideArg }, ({ guide }) => Effect.gen(function* () {
+	const name = guide.toLowerCase();
+	if (!allowedGuides.has(name)) {
+		yield* Console.log("Unknown guide. Use one of: index, setup, api, migrate.");
+		return;
+	}
+	const content = yield* Effect.tryPromise(() => readGuide(name));
+	yield* Console.log(content);
+})).pipe(Command.withDescription("Print Lingo guides (setup, api, migrate)."));
+//#endregion
+//#region src/commands/install.ts
+/**
+* `lingo install` - One command to set up the @lingo.dev/react DX stack.
+* Detects AI tools, installs packages, copies the /lingo skill.
+* Non-destructive and idempotent.
+*/
+async function exists(p) {
+	try {
+		await fs$1.access(p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Walk up from cwd looking for a file/dir. Returns the directory containing it, or null. */
+async function findUp(name, from) {
+	let dir = from;
+	while (true) {
+		if (await exists(path.join(dir, name))) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+async function detectProject(cwd) {
+	const lockfiles = [
+		["pnpm-lock.yaml", "pnpm"],
+		["bun.lockb", "bun"],
+		["bun.lock", "bun"],
+		["yarn.lock", "yarn"],
+		["package-lock.json", "npm"]
+	];
+	let pm = "npm";
+	for (const [file, manager] of lockfiles) if (await findUp(file, cwd)) {
+		pm = manager;
+		break;
+	}
+	let framework = "unknown";
+	const pkgPath = path.join(cwd, "package.json");
+	if (await exists(pkgPath)) {
+		const pkg = JSON.parse(await fs$1.readFile(pkgPath, "utf8"));
+		const deps = {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		};
+		if (deps.next) {
+			const hasPages = await exists(path.join(cwd, "pages")) || await exists(path.join(cwd, "src/pages"));
+			const hasApp = await exists(path.join(cwd, "app")) || await exists(path.join(cwd, "src/app"));
+			framework = hasPages ? "next-pages" : hasApp ? "next-app" : "next-pages";
+		} else if (deps.vite) framework = "vite";
+		else if (deps.react) framework = "react";
+	}
+	const aiToolDirs = [
+		[".claude", "claude-code"],
+		[".cursor", "cursor"],
+		[".windsurf", "windsurf"],
+		[".vscode", "vscode"]
+	];
+	const aiTools = [];
+	for (const [dir, tool] of aiToolDirs) if (await findUp(dir, cwd)) aiTools.push(tool);
+	return {
+		framework,
+		pm,
+		aiTools
+	};
+}
+function installCmd(pm, packages, dev) {
+	return [
+		pm,
+		pm === "yarn" ? "add" : pm === "npm" ? "install" : "add",
+		dev ? pm === "npm" ? "--save-dev" : "-D" : "",
+		...packages
+	].filter(Boolean).join(" ");
+}
+async function installPackages(cwd, pm, framework) {
+	const pkgPath = path.join(cwd, "package.json");
+	const pkg = JSON.parse(await fs$1.readFile(pkgPath, "utf8"));
+	const allDeps = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	const toInstall = [];
+	if (!allDeps["@lingo.dev/react"]) toInstall.push("@lingo.dev/react");
+	if (framework.startsWith("next") && !allDeps["@lingo.dev/react-next"]) toInstall.push("@lingo.dev/react-next");
+	const toInstallDev = [];
+	if (!allDeps["@lingo.dev/cli"]) toInstallDev.push("@lingo.dev/cli");
+	const commands = [];
+	if (toInstall.length > 0) commands.push(installCmd(pm, toInstall, false));
+	if (toInstallDev.length > 0) commands.push(installCmd(pm, toInstallDev, true));
+	return commands;
+}
+const AI_TOOL_DIR = {
+	"claude-code": ".claude",
+	cursor: ".cursor",
+	windsurf: ".windsurf",
+	vscode: ".vscode"
+};
+const SKILL_NAMES = ["lingo"];
+async function copySkills(cwd, aiTools, skillsSourceDir) {
+	const copied = [];
+	for (const tool of aiTools) {
+		const root = await findUp(AI_TOOL_DIR[tool], cwd);
+		if (!root) continue;
+		const targetDir = path.join(root, AI_TOOL_DIR[tool], "skills");
+		for (const name of SKILL_NAMES) {
+			const src = path.join(skillsSourceDir, name, "SKILL.md");
+			const dest = path.join(targetDir, name, "SKILL.md");
+			if (await exists(dest)) continue;
+			await fs$1.mkdir(path.dirname(dest), { recursive: true });
+			await fs$1.copyFile(src, dest);
+			copied.push(`${tool}: ${name}`);
+		}
+	}
+	return copied;
+}
+const installCommand = Command.make("install", {}, () => Effect.gen(function* () {
+	const cwd = process.cwd();
+	const project = yield* Effect.tryPromise(() => detectProject(cwd));
+	yield* Console.log(`  Detected: ${{
+		"next-pages": "Next.js Pages Router",
+		"next-app": "Next.js App Router",
+		vite: "Vite + React",
+		react: "React",
+		unknown: "React (unknown framework)"
+	}[project.framework]}`);
+	yield* Console.log(`  Detected: ${project.pm} (package manager)`);
+	if (project.aiTools.length > 0) yield* Console.log(`  Detected: ${project.aiTools.join(", ")} (AI tools)`);
+	yield* Console.log("");
+	const commands = yield* Effect.tryPromise(() => installPackages(cwd, project.pm, project.framework));
+	if (commands.length > 0) {
+		for (const cmd of commands) yield* Console.log(`  Run: ${cmd}`);
+		yield* Console.log("");
+	} else yield* Console.log("  Packages already installed.");
+	if (project.aiTools.length > 0) {
+		const thisDir = path.dirname(new URL(import.meta.url).pathname);
+		const candidates = [path.resolve(thisDir, "..", "..", "skills"), path.resolve(thisDir, "..", "skills")];
+		const skillsDir = yield* Effect.tryPromise(async () => {
+			for (const c of candidates) if (await exists(c)) return c;
+			return "";
+		});
+		if (yield* Effect.tryPromise(() => exists(skillsDir))) if ((yield* Effect.tryPromise(() => copySkills(cwd, project.aiTools, skillsDir))).length > 0) yield* Console.log(`  Installed /lingo skill for: ${project.aiTools.join(", ")}`);
+		else yield* Console.log("  Skills already installed.");
+		else yield* Console.log("  Skills directory not found (running from source). Skipping skill copy.");
+	}
+	yield* Console.log("");
+	yield* Console.log("  Run /lingo in your AI assistant, or \"npx @lingo.dev/cli guide\" for instructions.");
+})).pipe(Command.withDescription("Set up @lingo.dev/react DX stack: packages, skills"));
+//#endregion
+//#region src/constants.ts
+const TAGLINE = "Lingo.dev — The Localization Engineering Platform";
+//#endregion
+//#region src/services/banner.ts
+const SCRAMBLE_GLYPHS = "░▒▓█▄▀╔╗╚╝║═╬╦╩╠╣┃━";
+const FRAME_MS = 20;
+const REVEAL_MS = 1200;
+const SETTLE_MS = 300;
+const COLUMN_JITTER_MS = 120;
+const GLITCH_ZONE_MS = 80;
+const ANSI_RE = /\x1B\[[0-9;]*m/g;
+const stripAnsi$1 = (s) => s.replace(ANSI_RE, "");
+function randomGlyph() {
+	return SCRAMBLE_GLYPHS[Math.floor(Math.random() * 19)];
+}
+function shouldSkip() {
+	return !!(process.env.NO_COLOR || process.env.CI || !process.stdout.isTTY);
+}
+function renderArt() {
+	const result = cfonts.render("Lingo.dev", {
+		font: "block",
+		space: false
+	});
+	if (!result) return [];
+	return stripAnsi$1(result.string).split("\n").filter((line) => line.trim().length > 0);
+}
+function computeRevealTimes(width) {
+	return Array.from({ length: width }, (_, col) => {
+		const base = col / width * REVEAL_MS;
+		const jitter = (Math.random() - .5) * COLUMN_JITTER_MS;
+		return Math.max(0, base + jitter);
+	});
+}
+function buildFrame(lines, elapsed, revealTimes) {
+	return lines.map((line) => Array.from(line).map((char, col) => {
+		if (char === " ") return " ";
+		const revealAt = revealTimes[col] ?? 0;
+		if (elapsed >= revealAt) return char;
+		if (revealAt - elapsed < GLITCH_ZONE_MS && Math.random() > .5) return char;
+		return randomGlyph();
+	}).join("")).join("\n");
+}
+const CLEAR_SCREEN = "\x1B[2J\x1B[H";
+function animateBanner(signal) {
+	if (shouldSkip()) return Promise.resolve();
+	const lines = renderArt();
+	if (lines.length === 0) return Promise.resolve();
+	const revealTimes = computeRevealTimes(Math.max(...lines.map((l) => l.length)));
+	const totalMs = REVEAL_MS + SETTLE_MS;
+	process.stdout.write(CLEAR_SCREEN);
+	return new Promise((resolve) => {
+		const start = Date.now();
+		const tick = setInterval(() => {
+			if (signal?.aborted) {
+				clearInterval(tick);
+				logUpdate.clear();
+				resolve();
+				return;
+			}
+			const elapsed = Date.now() - start;
+			logUpdate("\n" + buildFrame(lines, elapsed, revealTimes));
+			if (elapsed >= totalMs) {
+				clearInterval(tick);
+				logUpdate("\n" + lines.join("\n"));
+				logUpdate.done();
+				resolve();
+			}
+		}, FRAME_MS);
+	});
+}
+//#endregion
+//#region src/services/prompt.ts
+var PromptCancelledError = class extends Data.TaggedError("PromptCancelledError") {};
+function unwrapCancel(value) {
+	if (clack.isCancel(value)) return Effect.fail(new PromptCancelledError({ message: "Cancelled." }));
+	return Effect.succeed(value);
+}
+const text = (opts) => Effect.flatMap(Effect.tryPromise(() => clack.text(opts)), unwrapCancel);
+const select = (opts) => Effect.flatMap(Effect.tryPromise(() => clack.select(opts)), unwrapCancel);
+const multiselect = (opts) => Effect.flatMap(Effect.tryPromise(() => clack.multiselect(opts)), unwrapCancel);
+const spinner = () => clack.spinner();
+const cancel = (message) => Effect.sync(() => clack.cancel(message));
+const log = {
+	info: (message) => Effect.sync(() => clack.log.info(message)),
+	success: (message) => Effect.sync(() => clack.log.success(message)),
+	warn: (message) => Effect.sync(() => clack.log.warn(message)),
+	error: (message) => Effect.sync(() => clack.log.error(message)),
+	step: (message) => Effect.sync(() => clack.log.step(message)),
+	message: (message) => Effect.sync(() => clack.log.message(message))
+};
+//#endregion
+//#region src/services/telemetry.ts
+var TelemetryService = class extends Context.Tag("TelemetryService")() {};
+const noop = {
+	capture: () => Effect.void,
+	identify: () => Effect.void,
+	shutdown: Effect.void
+};
+function resolveRepoId() {
+	return process.env.GITHUB_REPOSITORY_ID ?? process.env.CI_PROJECT_ID ?? process.env.BITBUCKET_REPO_UUID ?? hashOf(process.env.GITHUB_REPOSITORY ?? process.env.CI_PROJECT_PATH ?? process.env.CIRCLE_PROJECT_REPONAME ?? process.cwd());
+}
+function detectCI() {
+	if (!ci.isCI) return {
+		isCI: false,
+		provider: null,
+		isPR: null,
+		repoId: null
+	};
+	return {
+		isCI: true,
+		provider: ci.id,
+		isPR: ci.isPR,
+		repoId: resolveRepoId()
+	};
+}
+function getAnonymousId() {
+	const dir = path.join(os.homedir(), ".lingo");
+	const file = path.join(dir, "anonymous-id");
+	try {
+		return fs.readFileSync(file, "utf-8").trim();
+	} catch {
+		const id = crypto.randomUUID();
+		try {
+			fs.mkdirSync(dir, { recursive: true });
+			fs.writeFileSync(file, id);
+		} catch {}
+		return id;
+	}
+}
+function resolveDistinctId(ci, orgId, engineId) {
+	if (!ci.isCI) return getAnonymousId();
+	return `ci:${[
+		ci.provider ?? "ci",
+		ci.repoId,
+		orgId,
+		engineId
+	].filter(Boolean).join(":")}`;
+}
+function isDisabled() {
+	if (process.env.LINGO_TELEMETRY_DISABLED === "1") return true;
+	if (process.env.DO_NOT_TRACK === "1") return true;
+	return false;
+}
+function hashOf(input) {
+	return crypto.createHash("sha256").update(input).digest("hex").slice(0, 12);
+}
+const POSTHOG_KEY = "phc_eR0iSoQufBxNY36k0f0T15UvHJdTfHlh8rJcxsfhfXk";
+const POSTHOG_HOST = "https://eu.i.posthog.com";
+const FLUSH_SCRIPT = path.join(path.dirname(fileURLToPath(import.meta.url)), "flush-telemetry.js");
+const TelemetryServiceLive = Layer.effect(TelemetryService, Effect.gen(function* () {
+	if (isDisabled()) return noop;
+	const projectConfig = yield* pipe((yield* ConfigService).resolve, Effect.catchAll(() => Effect.succeed(null)));
+	const ciCtx = detectCI();
+	const distinctId = resolveDistinctId(ciCtx, projectConfig?.orgId ?? null, projectConfig?.engineId ?? null);
+	const creds = yield* pipe((yield* AuthService).resolve, Effect.catchAll(() => Effect.succeed(null)));
+	let identifyTraits;
+	if (creds?.type === "session") identifyTraits = { email: creds.email };
+	else if (creds?.type === "api-key") {
+		const me = yield* pipe((yield* ApiClient).getMe, Effect.catchAll(() => Effect.succeed(null)));
+		if (me) identifyTraits = {
+			email: me.email,
+			name: me.name,
+			user_id: me.id
+		};
+	}
+	const globalProperties = {
+		$lib: "@lingo.dev/cli",
+		cli_version: VERSION,
+		os: process.platform,
+		arch: process.arch,
+		node_version: process.version,
+		is_ci: ciCtx.isCI,
+		ci_provider: ciCtx.provider,
+		ci_pr: ciCtx.isPR,
+		auth_method: creds?.type ?? null,
+		has_project_config: !!projectConfig,
+		org_id: projectConfig?.orgId ?? null,
+		engine_id: projectConfig?.engineId ?? null,
+		is_tty: process.stdout.isTTY ?? false,
+		shell: process.env.SHELL ?? null
+	};
+	const buffer = [];
+	let flushed = false;
+	return {
+		capture: (event, properties) => Effect.sync(() => {
+			if (flushed) return;
+			buffer.push({
+				event,
+				properties: {
+					...globalProperties,
+					...properties
+				},
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		}),
+		identify: (traits) => Effect.sync(() => {
+			if (traits) identifyTraits = {
+				...identifyTraits,
+				...traits
+			};
+		}),
+		shutdown: Effect.sync(() => {
+			if (flushed) return;
+			flushed = true;
+			if (buffer.length === 0 && !identifyTraits) return;
+			const payload = {
+				apiKey: POSTHOG_KEY,
+				host: POSTHOG_HOST,
+				distinctId,
+				events: buffer,
+				identifyTraits
+			};
+			const file = path.join(os.tmpdir(), `lingo-telemetry-${process.pid}-${Date.now()}.json`);
+			try {
+				fs.writeFileSync(file, JSON.stringify(payload));
+			} catch {
+				return;
+			}
+			try {
+				spawn(process.execPath, [FLUSH_SCRIPT, file], {
+					detached: true,
+					stdio: "ignore",
+					windowsHide: true
+				}).unref();
+			} catch {
+				try {
+					fs.unlinkSync(file);
+				} catch {}
+			}
+		})
+	};
+}).pipe(Effect.catchAll(() => Effect.succeed(noop))));
+function trackCommand(commandName, flags) {
+	return (effect) => {
+		return Effect.gen(function* () {
+			const telemetry = yield* TelemetryService;
+			const start = Date.now();
+			yield* telemetry.capture("cli_command_started", {
+				command: commandName,
+				flags
+			});
+			const result = yield* pipe(effect, Effect.tapError((error) => {
+				const tag = "_tag" in error ? error._tag : "UnknownError";
+				const cancelled = tag === "PromptCancelledError";
+				return telemetry.capture("cli_command_completed", {
+					command: commandName,
+					success: false,
+					cancelled,
+					duration_ms: Date.now() - start,
+					...cancelled ? {} : { error_type: tag }
+				});
+			}));
+			yield* telemetry.capture("cli_command_completed", {
+				command: commandName,
+				success: true,
+				duration_ms: Date.now() - start,
+				error_type: null
+			});
+			return result;
+		});
+	};
+}
+//#endregion
+//#region src/commands/login.ts
+const email = pipe(Options.text("email"), Options.withDescription("Email address (skips prompt)"), Options.optional);
+const code = pipe(Options.text("code"), Options.withDescription("OTP code (skips prompt, requires --email)"), Options.optional);
+const apiKey = pipe(Options.text("api-key"), Options.withDescription("Authenticate with an API key instead of email"), Options.optional);
+const loginCommand = Command.make("login", {
+	email,
+	code,
+	apiKey
+}, ({ email: emailOpt, code: codeOpt, apiKey: apiKeyOpt }) => Effect.gen(function* () {
+	const auth = yield* AuthService;
+	const apiKeyValue = Option.getOrUndefined(apiKeyOpt);
+	const emailFlag = Option.getOrUndefined(emailOpt);
+	const codeFlag = Option.getOrUndefined(codeOpt);
+	const telemetry = yield* TelemetryService;
+	if (apiKeyValue) {
+		yield* auth.store({
+			type: "api-key",
+			apiKey: apiKeyValue
+		});
+		yield* telemetry.capture("cli_login", { method: "api-key" });
+		yield* log.success("Authenticated with API key.");
+		return;
+	}
+	yield* Effect.async((resume, signal) => {
+		animateBanner(signal).then(() => resume(Effect.void));
+	});
+	yield* log.step(pc.dim(TAGLINE));
+	const emailAddress = emailFlag ?? (yield* text({
+		message: "Email",
+		validate: (v) => !v.includes("@") ? "Enter a valid email address." : void 0
+	}));
+	const s = spinner();
+	s.start("Sending code...");
+	yield* sendOtp(emailAddress);
+	s.stop(`Code sent to ${pc.green(emailAddress)}. Check your inbox.`);
+	const otpCode = codeFlag ?? (yield* text({
+		message: "Verification code",
+		placeholder: "6-digit code from email"
+	}));
+	s.start("Verifying...");
+	const session = yield* verifyOtp(emailAddress, otpCode);
+	s.stop(`Authenticated as ${pc.green(emailAddress)}.`);
+	const creds = {
+		type: "session",
+		email: session.user.email ?? emailAddress,
+		accessToken: session.access_token,
+		refreshToken: session.refresh_token,
+		expiresAt: session.expires_at ?? Math.floor(Date.now() / 1e3) + session.expires_in
+	};
+	yield* auth.store(creds);
+	yield* telemetry.capture("cli_login", { method: "otp" });
+	yield* telemetry.identify({ email: creds.email });
+})).pipe(Command.withDescription("Authenticate with Lingo.dev"));
+//#endregion
+//#region src/commands/logout.ts
+const logoutCommand = Command.make("logout", {}, () => Effect.gen(function* () {
+	const auth = yield* AuthService;
+	const telemetry = yield* TelemetryService;
+	yield* auth.clear;
+	yield* telemetry.capture("cli_logout");
+	yield* log.success("Logged out.");
+})).pipe(Command.withDescription("Clear stored credentials"));
+//#endregion
+//#region src/commands/whoami.ts
+const json = Options.boolean("json").pipe(Options.withDescription("Output as JSON"));
+const whoamiCommand = Command.make("whoami", { json }, ({ json }) => Effect.gen(function* () {
+	const auth = yield* AuthService;
+	const api = yield* ApiClient;
+	const config = yield* ConfigService;
+	const creds = yield* auth.resolve;
+	const projectConfig = yield* config.resolve;
+	const info = {};
+	if (creds.type === "session") {
+		const me = yield* pipe(api.getMe, Effect.catchAll(() => Effect.succeed(null)));
+		info.email = me?.email ?? creds.email;
+		if (me?.name) info.name = me.name;
+		info.auth = "session";
+	} else info.auth = "api-key";
+	if (projectConfig) {
+		info.orgId = projectConfig.orgId;
+		info.engineId = projectConfig.engineId;
+		if (creds.type === "session") {
+			const org = (yield* pipe(api.listMemberships, Effect.catchAll(() => Effect.succeed([])))).find((m) => m.organizationId === projectConfig.orgId);
+			if (org) info.org = org.organizationName;
+		}
+		if (info.orgId) {
+			const eng = (yield* pipe(api.listEngines(info.orgId), Effect.catchAll(() => Effect.succeed([])))).find((e) => e.id === projectConfig.engineId);
+			if (eng) info.engine = eng.name;
+		}
+	}
+	if (json) yield* Console.log(JSON.stringify(info));
+	else {
+		const lines = [];
+		if (info.email) lines.push(`  ${pc.bold("Email:")}   ${pc.green(info.email)}`);
+		if (info.org) lines.push(`  ${pc.bold("Org:")}     ${info.org} ${pc.dim(`(${info.orgId})`)}`);
+		else if (info.orgId) lines.push(`  ${pc.bold("Org:")}     ${pc.dim(info.orgId)}`);
+		if (info.engine) lines.push(`  ${pc.bold("Engine:")}  ${info.engine} ${pc.dim(`(${info.engineId})`)}`);
+		else if (info.engineId) lines.push(`  ${pc.bold("Engine:")}  ${pc.dim(info.engineId)}`);
+		lines.push(`  ${pc.bold("Auth:")}    ${info.auth}`);
+		yield* Console.log(lines.join("\n"));
+	}
+})).pipe(Command.withDescription("Show current identity and context"));
+//#endregion
+//#region src/commands/link.ts
+const CREATE_NEW = "__create_new__";
+const org = pipe(Options.text("org"), Options.withDescription("Organization ID (skips prompt)"), Options.optional);
+const engine = pipe(Options.text("engine"), Options.withDescription("Engine ID (skips prompt)"), Options.optional);
+const linkCommand = Command.make("link", {
+	org,
+	engine
+}, ({ org: orgOpt, engine: engineOpt }) => Effect.gen(function* () {
+	yield* (yield* AuthService).resolve;
+	const api = yield* ApiClient;
+	const config = yield* ConfigService;
+	const telemetry = yield* TelemetryService;
+	const orgFlag = Option.getOrUndefined(orgOpt);
+	const engineFlag = Option.getOrUndefined(engineOpt);
+	let orgId;
+	let orgName;
+	let createdOrg = false;
+	let createdEngine = false;
+	if (orgFlag) {
+		orgId = orgFlag;
+		orgName = orgFlag;
+	} else {
+		const memberships = yield* api.listMemberships;
+		const selected = yield* select({
+			message: "Organization",
+			options: [...memberships.map((m) => ({
+				value: m.organizationId,
+				label: m.organizationName,
+				hint: pc.dim(m.organizationId)
+			})), {
+				value: CREATE_NEW,
+				label: pc.dim("Create new organization")
+			}]
+		});
+		if (selected === CREATE_NEW) {
+			const result = yield* createOrganization(api);
+			orgId = result.orgId;
+			orgName = result.orgName;
+			createdOrg = true;
+		} else {
+			orgId = selected;
+			orgName = memberships.find((m) => m.organizationId === orgId)?.organizationName ?? orgId;
+		}
+	}
+	let engineId;
+	let engineName;
+	if (engineFlag) {
+		engineId = engineFlag;
+		engineName = engineFlag;
+	} else {
+		const engines = yield* api.listEngines(orgId);
+		const selected = yield* select({
+			message: "Localization engine",
+			options: [...engines.map((e) => ({
+				value: e.id,
+				label: e.name,
+				hint: e.description ? pc.dim(e.description) : void 0
+			})), {
+				value: CREATE_NEW,
+				label: pc.dim("Create new engine")
+			}]
+		});
+		if (selected === CREATE_NEW) {
+			const result = yield* createEngine(api, orgId);
+			engineId = result.engineId;
+			engineName = result.engineName;
+			createdEngine = true;
+		} else {
+			engineId = selected;
+			engineName = engines.find((e) => e.id === engineId)?.name ?? engineId;
+		}
+	}
+	yield* config.store({
+		orgId,
+		engineId
+	});
+	yield* telemetry.capture("cli_project_linked", {
+		created_org: createdOrg,
+		created_engine: createdEngine
+	});
+	yield* log.success(`Linked to ${pc.green(orgName)} / ${pc.green(engineName)}.`);
+	yield* log.message(pc.dim("Config saved to .lingo/config.json. Commit this file to your repository."));
+})).pipe(Command.withDescription("Connect this directory to an org and engine"));
+function createOrganization(api) {
+	return Effect.gen(function* () {
+		const name = yield* text({
+			message: "Organization name",
+			placeholder: "Acme Inc"
+		});
+		const usecases = yield* multiselect({
+			message: "What are you planning to use Lingo.dev for? (space to select, enter to confirm)",
+			required: true,
+			options: [
+				{
+					value: "web-app",
+					label: "Web app localization"
+				},
+				{
+					value: "mobile-app",
+					label: "Mobile app localization"
+				},
+				{
+					value: "translation-api",
+					label: "Translation API"
+				},
+				{
+					value: "ci-cd",
+					label: "CI/CD localization workflows"
+				},
+				{
+					value: "static-content",
+					label: "Static content localization (e.g. Markdown, JSON)"
+				},
+				{
+					value: "cms",
+					label: "CMS content localization"
+				},
+				{
+					value: "emails",
+					label: "Emails localization"
+				}
+			]
+		});
+		const attribution = yield* text({
+			message: "How did you hear about us?",
+			placeholder: "e.g. Twitter, Reddit, coworker...",
+			validate: (v) => !v.trim() ? "This helps us build a better product." : void 0
+		});
+		yield* pipe(api.updateMe({
+			usecases,
+			selfAttribution: attribution.trim()
+		}), Effect.catchAll(() => Effect.void));
+		const s = spinner();
+		s.start("Creating organization...");
+		const created = yield* api.createOrganization(name);
+		s.stop(`Created organization ${pc.green(created.name)}.`);
+		return {
+			orgId: created.id,
+			orgName: created.name
+		};
+	});
+}
+function createEngine(api, orgId) {
+	return Effect.gen(function* () {
+		yield* log.message(pc.dim("A localization engine is a stateful translation API you configure for your project."));
+		const name = yield* text({
+			message: "Engine name",
+			placeholder: "default"
+		});
+		const s = spinner();
+		s.start("Creating localization engine...");
+		const created = yield* api.createEngine(orgId, name);
+		s.stop(`Created localization engine ${pc.green(created.name)}.`);
+		return {
+			engineId: created.id,
+			engineName: created.name
+		};
+	});
+}
+//#endregion
+//#region src/commands/unlink.ts
+const unlinkCommand = Command.make("unlink", {}, () => Effect.gen(function* () {
+	const config = yield* ConfigService;
+	const telemetry = yield* TelemetryService;
+	yield* config.clear;
+	yield* telemetry.capture("cli_project_unlinked");
+	yield* log.success("Unlinked.");
+})).pipe(Command.withDescription("Remove project config from this directory"));
+//#endregion
+//#region src/commands/update.ts
+const updateCommand = Command.make("update", {}, () => Effect.gen(function* () {
+	const update = yield* UpdateService;
+	const telemetry = yield* TelemetryService;
+	yield* log.step(`Current version: ${pc.dim(`v${VERSION}`)}`);
+	const info = yield* update.check;
+	if (!info) {
+		yield* log.success("Already up to date.");
+		return;
+	}
+	yield* log.info(`Update available: ${pc.dim(info.current)} → ${pc.green(info.latest)}`);
+	if (info.isMajor) yield* log.warn("This is a major version update. Review the changelog before upgrading.");
+	yield* telemetry.capture("cli_update_started", {
+		from_version: info.current,
+		to_version: info.latest,
+		install_method: update.installMethod.type
+	});
+	const s = spinner();
+	s.start("Updating...");
+	const result = yield* Effect.either(update.execute());
+	if (result._tag === "Left") {
+		s.stop("Update failed.");
+		const error = result.left;
+		if (error instanceof UpdateError) yield* log.info(error.message);
+		yield* telemetry.capture("cli_update_completed", {
+			from_version: info.current,
+			to_version: info.latest,
+			success: false
+		});
+		return;
+	}
+	s.stop("Updated successfully.");
+	yield* telemetry.capture("cli_update_completed", {
+		from_version: info.current,
+		to_version: info.latest,
+		success: true
+	});
+})).pipe(Command.withDescription("Update the CLI to the latest version"));
+//#endregion
+//#region src/cli.ts
+const subcommands = [
+	extractCommand,
+	localizeCommand,
+	shipCommand,
+	statusCommand,
+	checkCommand,
+	guideCommand,
+	installCommand,
+	loginCommand,
+	logoutCommand,
+	whoamiCommand,
+	linkCommand,
+	unlinkCommand,
+	updateCommand
+];
+const command = Command.make("lingo").pipe(Command.withDescription(TAGLINE), Command.withSubcommands([
+	extractCommand,
+	localizeCommand,
+	shipCommand,
+	statusCommand,
+	checkCommand,
+	guideCommand,
+	installCommand,
+	loginCommand,
+	logoutCommand,
+	whoamiCommand,
+	linkCommand,
+	unlinkCommand,
+	updateCommand
+]));
+const cliConfig = CliConfig.make({
+	showBuiltIns: false,
+	showTypes: false
+});
+const helpConfig = {
+	name: "lingo",
+	version: VERSION
+};
+const run = Command.run(command, {
+	name: helpConfig.name,
+	version: helpConfig.version
+});
+//#endregion
+//#region src/help/descriptor.ts
+function unwrapCommand(desc) {
+	if (desc._tag === "Map") return unwrapCommand(desc.command);
+	return desc;
+}
+function extractCommandInfo(desc) {
+	const cmd = unwrapCommand(desc);
+	return {
+		name: cmd.name,
+		description: extractDescription(cmd.description)
+	};
+}
+function collectArgs(node) {
+	if (!node) return [];
+	switch (node._tag) {
+		case "Empty": return [];
+		case "Single": return [{
+			name: extractPseudoName(node) || "arg",
+			description: extractDescription(node.description),
+			required: true
+		}];
+		case "Map": return collectArgs(node.args);
+		case "WithDefault": {
+			const inner = collectArgs(node.args);
+			const fallback = formatFallback(node.fallback);
+			return inner.map((a) => ({
+				...a,
+				required: false,
+				defaultValue: fallback
+			}));
+		}
+		case "Both": return [...collectArgs(node.left), ...collectArgs(node.right)];
+		case "Variadic": return collectArgs(node.args).map((a) => ({
+			...a,
+			required: false
+		}));
+		default: return [];
+	}
+}
+function collectOptions(node) {
+	if (!node) return [];
+	switch (node._tag) {
+		case "Empty": return [];
+		case "Single": return [singleToOptionInfo(node, true)];
+		case "Map": return collectOptions(node.options);
+		case "WithDefault": {
+			const inner = collectOptions(node.options);
+			const fallback = formatFallback(node.fallback);
+			return inner.map((o) => ({
+				...o,
+				required: false,
+				defaultValue: o.isBool ? void 0 : fallback
+			}));
+		}
+		case "Both": return [...collectOptions(node.left), ...collectOptions(node.right)];
+		case "Variadic": return collectOptions(node.argumentOption).map((o) => ({
+			...o,
+			required: false,
+			repeatable: true
+		}));
+		default: return [];
+	}
+}
+function singleToOptionInfo(node, required) {
+	const prim = node.primitiveType;
+	const isBool = prim?._tag === "Bool";
+	return {
+		long: node.name,
+		short: node.aliases?.[0],
+		type: isBool ? "" : primTypeName(prim),
+		description: extractDescription(node.description),
+		required,
+		repeatable: false,
+		isBool
+	};
+}
+function primTypeName(prim) {
+	if (!prim) return "value";
+	switch (prim._tag) {
+		case "Text": return "str";
+		case "Integer": return "int";
+		case "Float": return "num";
+		case "Date": return "date";
+		case "Bool": return "";
+		case "Choice": return prim.alternatives.map((a) => a[0]).join(" | ");
+		default: return "value";
+	}
+}
+function extractDescription(helpDoc) {
+	if (!helpDoc) return "";
+	return extractHelpDocText(helpDoc).trim();
+}
+function extractHelpDocText(doc) {
+	if (!doc) return "";
+	switch (doc._tag) {
+		case "Empty": return "";
+		case "Paragraph": return extractSpanText(doc.value);
+		case "Sequence": return [extractHelpDocText(doc.left), extractHelpDocText(doc.right)].filter(Boolean).join(" ");
+		case "Header": return extractSpanText(doc.value);
+		default: return "";
+	}
+}
+function extractSpanText(span) {
+	if (!span) return "";
+	switch (span._tag) {
+		case "Text": return span.value;
+		case "Strong":
+		case "Weak":
+		case "Highlight": return extractSpanText(span.value);
+		case "URI": return span.value;
+		case "Sequence": return extractSpanText(span.left) + extractSpanText(span.right);
+		default: return "";
+	}
+}
+function extractPseudoName(node) {
+	const pn = node.pseudoName;
+	if (pn && pn._tag === "Some") return pn.value;
+	return node.name?.replace(/[<>]/g, "");
+}
+function formatFallback(fallback) {
+	if (fallback === null || fallback === void 0) return void 0;
+	if (typeof fallback === "object" && "_tag" in fallback) {
+		if (fallback._tag === "None") return void 0;
+		if (fallback._tag === "Some") return formatFallback(fallback.value);
+	}
+	if (typeof fallback === "boolean") return fallback ? "true" : "false";
+	return String(fallback);
+}
+//#endregion
+//#region src/help/renderer.ts
+function renderRootHelp(config, subcommandDescriptors) {
+	const rootInfo = { name: config.name };
+	const subs = subcommandDescriptors.map((d) => extractCommandInfo(d));
+	const lines = [];
+	lines.push(`${pc.bold(rootInfo.name)} ${pc.dim(`v${config.version}`)}`);
+	lines.push("");
+	lines.push(`${pc.bold("Usage:")} ${rootInfo.name} <command> [flags]`);
+	if (subs.length > 0) {
+		lines.push("");
+		lines.push(pc.bold("Commands:"));
+		const maxLen = Math.max(...subs.map((s) => s.name.length));
+		for (const sub of subs) lines.push(`  ${pc.green(sub.name.padEnd(maxLen))}  ${pc.dim(sub.description)}`);
+	}
+	lines.push("");
+	lines.push(pc.dim(`Run ${rootInfo.name} <command> --help for more information.`));
+	return lines.join("\n");
+}
+function renderCommandHelp(config, descriptor) {
+	const cmd = unwrapCommand(descriptor);
+	const info = extractCommandInfo(descriptor);
+	const args = collectArgs(cmd.args);
+	const opts = collectOptions(cmd.options);
+	const lines = [];
+	lines.push(`${pc.bold(config.name)} ${pc.green(info.name)}${info.description ? ` ${pc.dim("-")} ${info.description}` : ""}`);
+	lines.push("");
+	const usageParts = [config.name, info.name];
+	for (const arg of args) usageParts.push(arg.required ? `<${arg.name}>` : `[${arg.name}]`);
+	if (opts.length > 0) usageParts.push("[flags]");
+	lines.push(`${pc.bold("Usage:")} ${usageParts.join(" ")}`);
+	if (args.length > 0) {
+		lines.push("");
+		lines.push(pc.bold("Arguments:"));
+		const maxLen = Math.max(...args.map((a) => a.name.length));
+		for (const arg of args) {
+			const name = pc.green(arg.name.padEnd(maxLen));
+			const parts = [arg.description];
+			if (arg.defaultValue !== void 0) parts.push(pc.dim(`[default: ${arg.defaultValue}]`));
+			lines.push(`  ${name}  ${parts.filter(Boolean).join(" ")}`);
+		}
+	}
+	if (opts.length > 0) {
+		lines.push("");
+		lines.push(pc.bold("Options:"));
+		const signatures = opts.map(formatOptionSignature);
+		const maxLen = Math.max(...signatures.map((s) => stripAnsi(s).length));
+		for (let i = 0; i < opts.length; i++) {
+			const sig = signatures[i];
+			const pad = " ".repeat(maxLen - stripAnsi(sig).length);
+			const parts = [opts[i].description];
+			if (opts[i].defaultValue !== void 0) parts.push(pc.dim(`[default: ${opts[i].defaultValue}]`));
+			if (opts[i].repeatable) parts.push(pc.dim("(repeatable)"));
+			lines.push(`  ${sig}${pad}  ${parts.filter(Boolean).join(" ")}`);
+		}
+	}
+	return lines.join("\n");
+}
+function formatOptionSignature(opt) {
+	return `${opt.short ? `${pc.yellow(`-${opt.short}`)}, ` : "    "}${pc.yellow(`--${opt.long}`)}${opt.type ? ` ${pc.dim(`<${opt.type}>`)}` : ""}`;
+}
+function stripAnsi(str) {
+	return str.replace(/\u001b\[[0-9;]*m/g, "");
+}
+//#endregion
+export { AuthService as C, AuthError as S, ConfigError as _, extractCommandInfo as a, ApiClientLive as b, command as c, subcommands as d, TelemetryService as f, cancel as g, PromptCancelledError as h, collectOptions as i, helpConfig as l, trackCommand as m, renderRootHelp as n, unwrapCommand as o, TelemetryServiceLive as p, collectArgs as r, cliConfig as s, renderCommandHelp as t, run as u, ConfigService as v, AuthServiceLive as w, AuthContext as x, ConfigServiceLive as y };