@dialexjs/cli 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1088 @@
+#!/usr/bin/env node
+import { C as saveDictionaryFile, _ as listLeaves, c as analyzeProject, d as TODO_PREFIX, f as copyLeaf, g as hasPath, h as getString, r as toKey, t as loadProject, v as listLocales, w as setString, y as loadDictionaryFile } from "./project-D4PmfqxM.mjs";
+import { Command } from "commander";
+import fs from "node:fs";
+import path from "node:path";
+import fg from "fast-glob";
+import chokidar from "chokidar";
+import { generateDts, resolveI18nConfig } from "dialexjs/scanner";
+import pc from "picocolors";
+import * as p from "@clack/prompts";
+import { loadFile, parseModule, writeFile } from "magicast";
+import { addNuxtModule, addVitePlugin } from "magicast/helpers";
+import { argumentSignature, getArguments, isIcuStructured, parseMessage } from "dialexjs/icu";
+//#region src/utils/logger.ts
+const logger = {
+	info: (msg) => console.log(pc.blue("ℹ ") + msg),
+	success: (msg) => console.log(pc.green("✔ ") + pc.bold(msg)),
+	warn: (msg) => console.warn(pc.yellow("⚠ ") + msg),
+	error: (msg) => console.error(pc.red("✖ ") + pc.bold(msg)),
+	log: (msg) => console.log(msg)
+};
+//#endregion
+//#region src/commands/generate.ts
+function generateDictionaries(root, options = {}) {
+	const inlineConfig = options.config ? { configFile: options.config } : {};
+	const config = resolveI18nConfig(root, inlineConfig);
+	const include = config.include || "**/*.content.ts";
+	const files = fg.sync(include, {
+		cwd: root,
+		absolute: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/.next/**"
+		]
+	});
+	const srcDir = fs.existsSync(path.join(root, "src")) ? path.join(root, "src") : root;
+	const targetOutput = options.output ? path.resolve(root, options.output) : path.join(srcDir, "i18n.generated.ts");
+	const targetDir = path.dirname(targetOutput);
+	generateDts(root, files, config.locales);
+	const dtsPath = path.join(srcDir, "dialex-env.d.ts");
+	const importLines = [];
+	const dictIdentifiers = [];
+	files.forEach((file, idx) => {
+		let rel = path.relative(targetDir, file).replace(/\\/g, "/");
+		rel = rel.replace(/\.ts$/, ".js");
+		if (!rel.startsWith(".")) rel = "./" + rel;
+		const id = `dict_${idx}`;
+		importLines.push(`import ${id} from "${rel}";`);
+		dictIdentifiers.push(id);
+	});
+	const content = `// Auto-generated by dialex CLI. Do not edit directly.
+/* eslint-disable */
+// @ts-nocheck
+${importLines.join("\n")}
+
+export const dictionaries = [
+  ${dictIdentifiers.join(",\n  ")}
+];
+
+export const dictionaryMap = {
+${dictIdentifiers.map((id) => `  [${id}.name]: ${id}.dictionary,`).join("\n")}
+};
+
+export default dictionaries;
+`;
+	fs.mkdirSync(targetDir, { recursive: true });
+	if ((fs.existsSync(targetOutput) ? fs.readFileSync(targetOutput, "utf-8") : "") !== content) fs.writeFileSync(targetOutput, content, "utf-8");
+	return {
+		files,
+		outputPath: targetOutput,
+		dtsPath
+	};
+}
+async function runGenerate(options = {}) {
+	const root = options.cwd || process.cwd();
+	const doGenerate = () => {
+		try {
+			const { files, outputPath, dtsPath } = generateDictionaries(root, options);
+			logger.success(`Generated dictionaries for ${files.length} file${files.length === 1 ? "" : "s"}:`);
+			logger.info(`→ ${path.relative(root, outputPath)}`);
+			logger.info(`→ ${path.relative(root, dtsPath)}`);
+		} catch (err) {
+			logger.error(`Generation failed: ${err.message || String(err)}`);
+		}
+	};
+	doGenerate();
+	if (options.watch) {
+		logger.info("Watching for dictionary changes (-w, --watch)...");
+		const inlineConfig = options.config ? { configFile: options.config } : {};
+		const pattern = resolveI18nConfig(root, inlineConfig).include || "**/*.content.ts";
+		chokidar.watch(pattern, {
+			cwd: root,
+			ignoreInitial: true,
+			ignored: [
+				"**/node_modules/**",
+				"**/dist/**",
+				"**/.next/**"
+			]
+		}).on("all", (event, filePath) => {
+			logger.info(`[${event}] ${filePath} changed, regenerating...`);
+			doGenerate();
+		});
+	}
+}
+//#endregion
+//#region src/utils/detector.ts
+/**
+* Automatically inspects package.json dependencies and configuration files
+* to detect the active framework in the target project.
+*/
+function detectFramework(root) {
+	const pkgPath = path.join(root, "package.json");
+	if (fs.existsSync(pkgPath)) try {
+		const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+		const allDeps = {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		};
+		if ("nuxt" in allDeps) return {
+			framework: "nuxt",
+			confidence: "high",
+			matchedRule: "package.json dependencies (nuxt)"
+		};
+		if ("@sveltejs/kit" in allDeps) return {
+			framework: "sveltekit",
+			confidence: "high",
+			matchedRule: "package.json dependencies (@sveltejs/kit)"
+		};
+		if ("astro" in allDeps) return {
+			framework: "astro",
+			confidence: "high",
+			matchedRule: "package.json dependencies (astro)"
+		};
+		if ("next" in allDeps) return {
+			framework: "next",
+			confidence: "high",
+			matchedRule: "package.json dependencies (next)"
+		};
+		if ("@nestjs/core" in allDeps || "@nestjs/common" in allDeps) return {
+			framework: "nestjs",
+			confidence: "high",
+			matchedRule: "package.json dependencies (@nestjs/core)"
+		};
+		if ("fastify" in allDeps) return {
+			framework: "fastify",
+			confidence: "high",
+			matchedRule: "package.json dependencies (fastify)"
+		};
+		if ("koa" in allDeps) return {
+			framework: "koa",
+			confidence: "high",
+			matchedRule: "package.json dependencies (koa)"
+		};
+		if ("express" in allDeps) return {
+			framework: "express",
+			confidence: "high",
+			matchedRule: "package.json dependencies (express)"
+		};
+		if ("elysia" in allDeps) return {
+			framework: "elysia",
+			confidence: "high",
+			matchedRule: "package.json dependencies (elysia)"
+		};
+		if ("hono" in allDeps) return {
+			framework: "hono",
+			confidence: "high",
+			matchedRule: "package.json dependencies (hono)"
+		};
+		if ("vue" in allDeps && !("react" in allDeps)) return {
+			framework: "vue",
+			confidence: "high",
+			matchedRule: "package.json dependencies (vue)"
+		};
+		if ("react" in allDeps || "vite" in allDeps) return {
+			framework: "react",
+			confidence: "high",
+			matchedRule: "package.json dependencies (react/vite)"
+		};
+	} catch {}
+	if (fs.existsSync(path.join(root, "next.config.js")) || fs.existsSync(path.join(root, "next.config.mjs")) || fs.existsSync(path.join(root, "next.config.ts"))) return {
+		framework: "next",
+		confidence: "medium",
+		matchedRule: "next.config file presence"
+	};
+	for (const [framework, base] of [
+		["nuxt", "nuxt.config"],
+		["sveltekit", "svelte.config"],
+		["astro", "astro.config"]
+	]) if ([
+		"js",
+		"mjs",
+		"ts"
+	].some((ext) => fs.existsSync(path.join(root, `${base}.${ext}`)))) return {
+		framework,
+		confidence: "medium",
+		matchedRule: `${base} file presence`
+	};
+	if (fs.existsSync(path.join(root, "vite.config.js")) || fs.existsSync(path.join(root, "vite.config.mjs")) || fs.existsSync(path.join(root, "vite.config.ts"))) return {
+		framework: "react",
+		confidence: "medium",
+		matchedRule: "vite.config file presence"
+	};
+	return {
+		framework: "hono",
+		confidence: "fallback",
+		matchedRule: "default fallback"
+	};
+}
+//#endregion
+//#region src/commands/init.ts
+async function runInit(options = {}) {
+	const root = options.cwd || process.cwd();
+	const detected = detectFramework(root);
+	const isInteractive = !options.yes && process.stdin.isTTY;
+	let framework = options.framework || detected.framework;
+	let defaultLocale = options.defaultLocale || "en";
+	let localesInput = options.locales || "en,tr";
+	if (isInteractive) {
+		p.intro(pc.bgCyan(pc.black(" dialex init ")));
+		const frameworkOptions = [
+			{
+				value: "hono",
+				label: "Hono",
+				hint: detected.framework === "hono" ? "detected" : void 0
+			},
+			{
+				value: "express",
+				label: "Express",
+				hint: detected.framework === "express" ? "detected" : void 0
+			},
+			{
+				value: "fastify",
+				label: "Fastify",
+				hint: detected.framework === "fastify" ? "detected" : void 0
+			},
+			{
+				value: "koa",
+				label: "Koa",
+				hint: detected.framework === "koa" ? "detected" : void 0
+			},
+			{
+				value: "nestjs",
+				label: "NestJS",
+				hint: detected.framework === "nestjs" ? "detected" : void 0
+			},
+			{
+				value: "next",
+				label: "Next.js",
+				hint: detected.framework === "next" ? "detected" : void 0
+			},
+			{
+				value: "react",
+				label: "React / Vite",
+				hint: detected.framework === "react" ? "detected" : void 0
+			},
+			{
+				value: "elysia",
+				label: "Elysia",
+				hint: detected.framework === "elysia" ? "detected" : void 0
+			},
+			{
+				value: "sveltekit",
+				label: "SvelteKit",
+				hint: detected.framework === "sveltekit" ? "detected" : void 0
+			},
+			{
+				value: "astro",
+				label: "Astro",
+				hint: detected.framework === "astro" ? "detected" : void 0
+			},
+			{
+				value: "vue",
+				label: "Vue / Vite",
+				hint: detected.framework === "vue" ? "detected" : void 0
+			},
+			{
+				value: "nuxt",
+				label: "Nuxt",
+				hint: detected.framework === "nuxt" ? "detected" : void 0
+			}
+		];
+		const selectedFramework = await p.select({
+			message: `Framework detected as ${pc.bold(detected.framework)} (${detected.matchedRule}). Select framework:`,
+			options: frameworkOptions,
+			initialValue: detected.framework
+		});
+		if (p.isCancel(selectedFramework)) {
+			p.cancel("Operation cancelled.");
+			return;
+		}
+		framework = selectedFramework;
+		const inputDefault = await p.text({
+			message: "What is your default locale?",
+			initialValue: "en",
+			validate: (v) => !v || !v.trim() ? "Default locale cannot be empty" : void 0
+		});
+		if (p.isCancel(inputDefault)) {
+			p.cancel("Operation cancelled.");
+			return;
+		}
+		defaultLocale = inputDefault.trim();
+		const inputLocales = await p.text({
+			message: "Comma-separated list of supported locales:",
+			initialValue: `${defaultLocale},tr`,
+			validate: (v) => !v || !v.trim() ? "Locales list cannot be empty" : void 0
+		});
+		if (p.isCancel(inputLocales)) {
+			p.cancel("Operation cancelled.");
+			return;
+		}
+		localesInput = inputLocales.trim();
+	} else logger.info(`Auto-detected framework: ${pc.bold(framework)} (${detected.matchedRule})`);
+	const localeList = Array.from(/* @__PURE__ */ new Set([defaultLocale, ...localesInput.split(",").map((s) => s.trim()).filter(Boolean)]));
+	const configPath = fs.existsSync(path.join(root, "dialex.config.ts")) ? path.join(root, "dialex.config.ts") : fs.existsSync(path.join(root, "i18n.config.ts")) ? path.join(root, "i18n.config.ts") : path.join(root, "dialex.config.ts");
+	const configFileName = path.basename(configPath);
+	try {
+		if (fs.existsSync(configPath)) {
+			const mod = await loadFile(configPath);
+			if (mod && mod.exports.default) {
+				if (mod.exports.default.$args && mod.exports.default.$args[0]) {
+					mod.exports.default.$args[0].defaultLocale = defaultLocale;
+					mod.exports.default.$args[0].locales = localeList;
+				}
+				await writeFile(mod, configPath);
+				logger.success(`Updated ${pc.bold(configFileName)} via Magicast`);
+			}
+		} else {
+			const mod = parseModule(`import { defineConfig } from "dialexjs";
+
+export default defineConfig({});
+`);
+			mod.exports.default.$args[0].defaultLocale = defaultLocale;
+			mod.exports.default.$args[0].locales = localeList;
+			await writeFile(mod, configPath);
+			logger.success(`Created ${pc.bold(configFileName)} via Magicast`);
+		}
+	} catch (err) {
+		logger.warn(`Magicast config update notice: ${err.message || String(err)}`);
+		const fallback = `import { defineConfig } from "dialexjs";
+
+export default defineConfig({
+  defaultLocale: "${defaultLocale}",
+  locales: [${localeList.map((l) => `"${l}"`).join(", ")}],
+});
+`;
+		fs.writeFileSync(configPath, fallback, "utf-8");
+	}
+	if (framework === "react" || framework === "vue") {
+		const possibleViteConfigs = [
+			path.join(root, "vite.config.ts"),
+			path.join(root, "vite.config.js"),
+			path.join(root, "vite.config.mjs")
+		];
+		for (const vConfig of possibleViteConfigs) if (fs.existsSync(vConfig)) try {
+			const vMod = await loadFile(vConfig);
+			addVitePlugin(vMod, {
+				from: "dialexjs/vite",
+				imported: "i18nPlugin",
+				constructor: "i18nPlugin"
+			});
+			await writeFile(vMod, vConfig);
+			logger.success(`Injected i18nPlugin() into ${pc.bold(path.basename(vConfig))} via Magicast`);
+			break;
+		} catch {}
+	}
+	if (framework === "nuxt") {
+		const nuxtConfig = [
+			"nuxt.config.ts",
+			"nuxt.config.js",
+			"nuxt.config.mjs"
+		].map((f) => path.join(root, f)).find((f) => fs.existsSync(f));
+		if (nuxtConfig) try {
+			const nMod = await loadFile(nuxtConfig);
+			addNuxtModule(nMod, "dialexjs/nuxt", "dialex", {
+				defaultLocale,
+				locales: localeList
+			});
+			await writeFile(nMod, nuxtConfig);
+			logger.success(`Registered dialexjs/nuxt in ${pc.bold(path.basename(nuxtConfig))} via Magicast`);
+		} catch {
+			logger.warn("Could not update the Nuxt config; add the dialexjs/nuxt module manually.");
+		}
+	}
+	const targetDir = fs.existsSync(path.join(root, "src")) ? path.join(root, "src") : root;
+	const dictPath = path.join(targetDir, "home.content.ts");
+	if (!fs.existsSync(dictPath)) {
+		const dictContent = `import { defineDictionary } from "dialexjs";
+
+export default defineDictionary("home", {
+${localeList.map((loc) => `  ${loc}: {
+    title: "Welcome to Dialex (${loc})!",
+    description: "Type-safe internationalization.",
+    greeting: (name: string) => "Hello, " + name + "!",
+  },`).join("\n")}
+});
+`;
+		fs.writeFileSync(dictPath, dictContent, "utf-8");
+		logger.success(`Created starter dictionary at ${pc.bold(path.relative(root, dictPath))}`);
+	} else logger.info("home.content.ts already exists, skipping creation.");
+	generateDictionaries(root);
+	logger.success("Generated types and standalone dictionary registry!");
+	const pkgPath = path.join(root, "package.json");
+	if (fs.existsSync(pkgPath)) try {
+		const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+		pkg.scripts = pkg.scripts || {};
+		if (!pkg.scripts["i18n:generate"]) {
+			pkg.scripts["i18n:generate"] = "dialex generate";
+			fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+			logger.success("Added \"i18n:generate\" script to package.json");
+		}
+	} catch {}
+	logger.log("");
+	logger.info(pc.bold(`Quick start for ${framework.toUpperCase()}:`));
+	switch (framework) {
+		case "hono":
+			logger.log(`
+import { Hono } from "hono";
+import { i18n } from "dialexjs/hono";
+import dictionaries from "./src/i18n.generated.js";
+
+const app = new Hono();
+app.use("*", i18n({ dictionaries }));
+
+app.get("/", (c) => {
+  const dict = c.var.getDictionary("home");
+  return c.json({ title: dict.title });
+});
+`);
+			break;
+		case "fastify":
+			logger.log(`
+import Fastify from "fastify";
+import { i18nPlugin } from "dialexjs/fastify";
+import dictionaries from "./src/i18n.generated.js";
+
+const app = Fastify();
+await app.register(i18nPlugin, { dictionaries });
+
+app.get("/", (req) => {
+  const dict = req.getDictionary("home");
+  return { title: dict.title };
+});
+`);
+			break;
+		case "express":
+			logger.log(`
+import express from "express";
+import { i18n } from "dialexjs/express";
+import dictionaries from "./src/i18n.generated.js";
+
+const app = express();
+app.use(i18n({ dictionaries }));
+
+app.get("/", (req, res) => {
+  const dict = req.getDictionary("home");
+  res.json({ title: dict.title });
+});
+`);
+			break;
+		case "koa":
+			logger.log(`
+import Koa from "koa";
+import { i18n } from "dialexjs/koa";
+import dictionaries from "./src/i18n.generated.js";
+
+const app = new Koa();
+app.use(i18n({ dictionaries }));
+
+app.use((ctx) => {
+  const dict = ctx.getDictionary("home");
+  ctx.body = { title: dict.title };
+});
+`);
+			break;
+		case "nestjs":
+			logger.log(`
+import { Module } from "@nestjs/common";
+import { I18nModule } from "dialexjs/nestjs";
+import dictionaries from "./src/i18n.generated.js";
+
+@Module({
+  imports: [I18nModule.forRoot({ dictionaries })],
+})
+export class AppModule {}
+`);
+			break;
+		case "next":
+			logger.log(`
+import { getDictionary } from "dialexjs/server";
+
+export default async function Page({ params }: { params: Promise<{ locale: string }> }) {
+  const { locale = "en" } = await params;
+  const dict = getDictionary("home", locale);
+  return <h1>{dict.title}</h1>;
+}
+`);
+			break;
+		case "elysia":
+			logger.log(`
+import { Elysia } from "elysia";
+import { i18n } from "dialexjs/elysia";
+import dictionaries from "./src/i18n.generated.js";
+
+new Elysia()
+  .use(i18n({ dictionaries }))
+  .get("/", ({ getDictionary }) => ({ title: getDictionary("home").title }))
+  .listen(3000);
+`);
+			break;
+		case "sveltekit":
+			logger.log(`
+// src/hooks.server.ts
+import { i18nHandle } from "dialexjs/sveltekit";
+import dictionaries from "./i18n.generated.js";
+
+export const handle = i18nHandle({ dictionaries });
+
+// src/app.html: <html lang="%dialex.lang%">
+// In load functions: locals.getDictionary("home")
+`);
+			break;
+		case "astro":
+			logger.log(`
+// src/middleware.ts
+import { i18n } from "dialexjs/astro";
+import dictionaries from "./i18n.generated.js";
+
+export const onRequest = i18n({ dictionaries });
+
+// In pages: Astro.locals.getDictionary("home")
+`);
+			break;
+		case "vue":
+			logger.log(`
+// src/main.ts
+import { createApp } from "vue";
+import { createI18n } from "dialexjs/vue";
+import App from "./App.vue";
+
+createApp(App).use(createI18n()).mount("#app");
+
+// In components: const dict = useDictionary("home")
+`);
+			break;
+		case "nuxt":
+			logger.log(`
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ["dialexjs/nuxt"],
+});
+
+// In components: const dict = useDictionary("home")
+`);
+			break;
+		default: logger.log(`
+Import dictionaries and register your framework middleware to begin!
+Run \`npm run i18n:generate\` whenever you add new dictionary files.
+`);
+	}
+	if (isInteractive) p.outro(pc.green("✔ dialex is configured and ready to go!"));
+}
+//#endregion
+//#region src/commands/check.ts
+const DICTIONARY_IGNORE = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/.next/**"
+];
+function addIssue(diag, issue) {
+	const level = issue.level === "error" ? "error" : "warning";
+	(level === "error" ? diag.errors : diag.warnings).push(issue.message);
+	diag.annotations.push({
+		level,
+		message: issue.message,
+		line: issue.range ? issue.range.start.line + 1 : void 0
+	});
+}
+/**
+* Inserts keys that exist in one locale but not in another, copying the default-locale value
+* (strings get a `[TODO]` prefix). Returns how many keys were inserted.
+*/
+async function applyFixes(files, configuredLocales, defaultLocale) {
+	let fixed = 0;
+	for (const file of files) {
+		const df = await loadDictionaryFile(file);
+		if (!df?.complete) continue;
+		const present = listLocales(df);
+		const targets = Array.from(/* @__PURE__ */ new Set([...present, ...configuredLocales]));
+		const sourceOrder = [defaultLocale, ...present.filter((l) => l !== defaultLocale)].filter((l) => present.includes(l));
+		const allPaths = /* @__PURE__ */ new Map();
+		for (const locale of present) for (const leaf of listLeaves(df, locale)) allPaths.set(leaf.path.join("\0"), leaf.path);
+		let changed = false;
+		for (const target of targets) for (const leafPath of allPaths.values()) {
+			if (hasPath(df, target, leafPath)) continue;
+			const source = sourceOrder.find((l) => l !== target && hasPath(df, l, leafPath));
+			if (source && copyLeaf(df, source, target, leafPath, (v) => `[TODO] ${v}`)) {
+				fixed++;
+				changed = true;
+			}
+		}
+		if (changed) await saveDictionaryFile(df);
+	}
+	return fixed;
+}
+function escapeAnnotation(value) {
+	return value.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+}
+async function runCheck(options = {}) {
+	const root = options.cwd || process.cwd();
+	const quiet = options.json === true;
+	const inlineConfig = options.config ? { configFile: options.config } : {};
+	const config = resolveI18nConfig(root, inlineConfig);
+	const include = config.include || "**/*.content.ts";
+	const configuredLocales = config.locales || [];
+	const defaultLocale = config.defaultLocale || "en";
+	const files = fg.sync(include, {
+		cwd: root,
+		absolute: true,
+		ignore: DICTIONARY_IGNORE
+	});
+	if (files.length === 0) {
+		if (!quiet) {
+			const patternStr = Array.isArray(include) ? include.join(", ") : include;
+			logger.warn(`No dictionary files found matching "${patternStr}".`);
+		}
+		const empty = {
+			success: true,
+			diagnostics: [],
+			totalIssues: 0,
+			totalWarnings: 0,
+			fixed: 0
+		};
+		if (quiet) console.log(JSON.stringify(empty, null, 2));
+		return empty;
+	}
+	let fixed = 0;
+	if (options.fix) {
+		fixed = await applyFixes(files, configuredLocales, defaultLocale);
+		if (fixed > 0 && !quiet) logger.success(`Inserted ${fixed} missing key${fixed === 1 ? "" : "s"} marked ${TODO_PREFIX.trim()}`);
+	}
+	const analysis = await analyzeProject({
+		root,
+		config,
+		src: options.src && options.src.length > 0 ? options.src : void 0,
+		runtime: true
+	});
+	const byFile = /* @__PURE__ */ new Map();
+	const dictionaryFiles = new Set(analysis.files);
+	for (const issue of analysis.issues) {
+		if (issue.level === "info") continue;
+		const rel = path.relative(root, issue.file);
+		let diag = byFile.get(rel);
+		if (!diag) {
+			diag = {
+				file: rel,
+				errors: [],
+				warnings: [],
+				annotations: []
+			};
+			byFile.set(rel, diag);
+		}
+		if (dictionaryFiles.has(issue.file) && issue.dictionary && !diag.name) diag.name = issue.dictionary;
+		addIssue(diag, issue);
+	}
+	const diagnostics = [...byFile.values()];
+	const totalIssues = diagnostics.reduce((n, d) => n + d.errors.length, 0);
+	const totalWarnings = diagnostics.reduce((n, d) => n + d.warnings.length, 0);
+	const reported = diagnostics.filter((d) => d.errors.length > 0 || d.warnings.length > 0);
+	const result = {
+		success: totalIssues === 0,
+		diagnostics: reported,
+		totalIssues,
+		totalWarnings,
+		fixed
+	};
+	if (options.github) for (const d of reported) for (const a of d.annotations) {
+		const location = `file=${d.file}${a.line ? `,line=${a.line}` : ""}`;
+		console.log(`::${a.level} ${location},title=dialex::${escapeAnnotation(a.message)}`);
+	}
+	if (quiet) console.log(JSON.stringify(result, null, 2));
+	else if (reported.length > 0) {
+		logger.log("");
+		if (totalIssues > 0) logger.error(`Found ${totalIssues} issue${totalIssues === 1 ? "" : "s"} across ${reported.filter((d) => d.errors.length > 0).length} file${reported.length === 1 ? "" : "s"}:`);
+		logger.log("");
+		for (const d of reported) {
+			logger.log(`  ${pc.underline(pc.bold(d.file))} ${d.name ? pc.dim(`(${d.name})`) : ""}:`);
+			for (const a of d.annotations) {
+				const where = a.line ? pc.dim(`:${a.line}`) : "";
+				const mark = a.level === "error" ? pc.red("✖") : pc.yellow("⚠");
+				logger.log(`    ${mark} ${a.message}${where}`);
+			}
+			logger.log("");
+		}
+	}
+	if (totalIssues > 0) {
+		if (options.exitOnError !== false) process.exit(1);
+		return result;
+	}
+	if (!quiet) {
+		const warningNote = totalWarnings > 0 ? ` (${totalWarnings} warning${totalWarnings === 1 ? "" : "s"})` : "";
+		logger.success(`All ${files.length} dictionary file${files.length === 1 ? "" : "s"} passed checks with 0 issues${warningNote}!`);
+	}
+	return result;
+}
+//#endregion
+//#region src/commands/export.ts
+const escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const csvCell = (value) => /[",\r\n]/.test(value) ? `"${value.replace(/"/g, "\"\"")}"` : value;
+async function runExport(options = {}) {
+	const root = options.cwd || process.cwd();
+	const format = options.format || "json";
+	if (![
+		"json",
+		"csv",
+		"xliff"
+	].includes(format)) throw new Error(`Unsupported format "${format}". Use json, csv, or xliff.`);
+	const outDir = path.resolve(root, options.out || "i18n-export");
+	const project = await loadProject(root, options.config);
+	const defaultLocale = project.config.defaultLocale || "en";
+	const table = /* @__PURE__ */ new Map();
+	const orderedKeys = /* @__PURE__ */ new Set();
+	let skippedFunctions = 0;
+	const localeSet = new Set(project.config.locales || []);
+	for (const { df } of project.dictionaries) listLocales(df).forEach((l) => localeSet.add(l));
+	let locales = Array.from(localeSet);
+	if (options.locale && options.locale.length > 0) locales = locales.filter((l) => options.locale.includes(l) || l === defaultLocale);
+	for (const locale of locales) table.set(locale, /* @__PURE__ */ new Map());
+	for (const { name, df } of project.dictionaries) for (const locale of listLocales(df)) {
+		if (!table.has(locale)) continue;
+		for (const leaf of listLeaves(df, locale)) if (leaf.kind === "string" && leaf.value !== void 0) {
+			const key = toKey(name, leaf.path);
+			table.get(locale).set(key, leaf.value);
+			orderedKeys.add(key);
+		} else if (locale === defaultLocale) skippedFunctions++;
+	}
+	fs.mkdirSync(outDir, { recursive: true });
+	const files = [];
+	const write = (name, content) => {
+		const file = path.join(outDir, name);
+		fs.writeFileSync(file, content, "utf-8");
+		files.push(path.relative(root, file));
+	};
+	if (format === "json") for (const [locale, values] of table) write(`${locale}.json`, JSON.stringify(Object.fromEntries(values), null, 2) + "\n");
+	else if (format === "csv") write("translations.csv", [["key", ...table.keys()].map(csvCell).join(","), ...[...orderedKeys].map((key) => [key, ...[...table.values()].map((v) => v.get(key) ?? "")].map(csvCell).join(","))].join("\n") + "\n");
+	else {
+		const source = table.get(defaultLocale);
+		for (const [locale, values] of table) {
+			if (locale === defaultLocale) continue;
+			const units = [...orderedKeys].map((key) => {
+				const src = source?.get(key) ?? "";
+				const target = values.get(key);
+				const targetXml = target === void 0 ? "" : `<target>${escapeXml(target)}</target>`;
+				return `      <trans-unit id="${escapeXml(key)}"><source>${escapeXml(src)}</source>${targetXml}</trans-unit>`;
+			});
+			write(`${locale}.xlf`, `<?xml version="1.0" encoding="UTF-8"?>
+<xliff version="1.2" xmlns="urn:oasis:names:tc:xliff:document:1.2">
+  <file original="dialex" source-language="${escapeXml(defaultLocale)}" target-language="${escapeXml(locale)}" datatype="plaintext">
+    <body>
+${units.join("\n")}
+    </body>
+  </file>
+</xliff>
+`);
+		}
+	}
+	logger.success(`Exported ${orderedKeys.size} key${orderedKeys.size === 1 ? "" : "s"} to ${files.length} ${format} file${files.length === 1 ? "" : "s"} in ${path.relative(root, outDir) || "."}`);
+	if (skippedFunctions > 0) logger.warn(`${skippedFunctions} function value${skippedFunctions === 1 ? "" : "s"} skipped (not translatable as text)`);
+	for (const file of project.unsupported) logger.warn(`Skipped ${file}: unsupported dictionary shape`);
+	return {
+		files,
+		keys: orderedKeys.size,
+		skippedFunctions,
+		skippedFiles: project.unsupported
+	};
+}
+//#endregion
+//#region src/commands/import.ts
+const unescapeXml = (value) => value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+function parseCsv(text) {
+	const rows = [];
+	let row = [];
+	let cell = "";
+	let quoted = false;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		if (quoted) {
+			if (ch === "\"" && text[i + 1] === "\"") {
+				cell += "\"";
+				i++;
+			} else if (ch === "\"") quoted = false;
+			else cell += ch;
+		} else if (ch === "\"") quoted = true;
+		else if (ch === ",") {
+			row.push(cell);
+			cell = "";
+		} else if (ch === "\n" || ch === "\r") {
+			if (ch === "\r" && text[i + 1] === "\n") i++;
+			row.push(cell);
+			rows.push(row);
+			row = [];
+			cell = "";
+		} else cell += ch;
+	}
+	if (cell !== "" || row.length > 0) {
+		row.push(cell);
+		rows.push(row);
+	}
+	return rows.filter((r) => r.some((c) => c !== ""));
+}
+function parseEntries(content, format, fallbackLocale) {
+	const entries = [];
+	if (format === "json") {
+		const data = JSON.parse(content);
+		if (Object.keys(data).length > 0 && Object.values(data).every((v) => v && typeof v === "object" && !Array.isArray(v))) {
+			for (const [locale, values] of Object.entries(data)) for (const [key, value] of Object.entries(values)) if (typeof value === "string") entries.push({
+				locale,
+				key,
+				value
+			});
+		} else {
+			if (!fallbackLocale) throw new Error("Cannot infer the locale; pass --locale.");
+			for (const [key, value] of Object.entries(data)) if (typeof value === "string") entries.push({
+				locale: fallbackLocale,
+				key,
+				value
+			});
+		}
+	} else if (format === "csv") {
+		const [header, ...rows] = parseCsv(content);
+		if (!header || header[0] !== "key") throw new Error("CSV must start with a \"key\" column.");
+		for (const row of rows) header.slice(1).forEach((locale, i) => {
+			const value = row[i + 1];
+			if (value !== void 0 && value !== "") entries.push({
+				locale,
+				key: row[0],
+				value
+			});
+		});
+	} else {
+		const locale = /target-language="([^"]*)"/.exec(content)?.[1] ?? fallbackLocale;
+		if (!locale) throw new Error("Cannot infer the locale; pass --locale.");
+		for (const match of content.matchAll(/<trans-unit\b[^>]*\bid="([^"]*)"[^>]*>([\s\S]*?)<\/trans-unit>/g)) {
+			const target = /<target\b[^>]*>([\s\S]*?)<\/target>/.exec(match[2])?.[1];
+			if (target !== void 0 && target !== "") entries.push({
+				locale,
+				key: unescapeXml(match[1]),
+				value: unescapeXml(target)
+			});
+		}
+	}
+	return entries;
+}
+function inferFormat(file) {
+	const ext = path.extname(file).toLowerCase();
+	if (ext === ".json") return "json";
+	if (ext === ".csv") return "csv";
+	if (ext === ".xlf" || ext === ".xliff") return "xliff";
+	throw new Error(`Cannot infer format from "${ext}". Pass --format json|csv|xliff.`);
+}
+/**
+* Why `value` must not replace the current text, if it is an ICU message that is invalid or uses
+* different arguments than the same key in another locale.
+*/
+function icuProblem(df, defaultLocale, locale, keyPath, value) {
+	if (!value.includes("{")) return void 0;
+	let signature;
+	try {
+		signature = argumentSignature(parseMessage(value));
+	} catch (error) {
+		return `invalid ICU: ${error.message}`;
+	}
+	const locales = listLocales(df);
+	for (const other of [defaultLocale, ...locales.filter((l) => l !== defaultLocale)]) {
+		if (other === locale) continue;
+		const reference = getString(df, other, keyPath);
+		if (!reference?.includes("{")) continue;
+		try {
+			const expected = argumentSignature(parseMessage(reference));
+			return expected === signature ? void 0 : `arguments differ from "${other}": expected ${expected || "none"}, found ${signature || "none"}`;
+		} catch {
+			continue;
+		}
+	}
+}
+async function runImport(options) {
+	const root = options.cwd || process.cwd();
+	const file = path.resolve(root, options.file);
+	const format = options.format || inferFormat(file);
+	const fallbackLocale = options.locale ?? path.basename(file, path.extname(file));
+	const entries = parseEntries(fs.readFileSync(file, "utf-8"), format, options.locale ?? fallbackLocale);
+	const project = await loadProject(root, options.config);
+	const byName = new Map(project.dictionaries.map((d) => [d.name, d]));
+	const result = {
+		created: 0,
+		updated: 0,
+		skipped: [],
+		rejected: [],
+		unknown: [],
+		errors: []
+	};
+	const touched = /* @__PURE__ */ new Set();
+	for (const { locale, key, value } of entries) {
+		const [name, ...keyPath] = key.split(".");
+		const dict = byName.get(name);
+		if (!dict || keyPath.length === 0) {
+			result.unknown.push(key);
+			continue;
+		}
+		if (!listLocales(dict.df).some((l) => hasPath(dict.df, l, keyPath)) && !options.allowNew) {
+			result.unknown.push(key);
+			continue;
+		}
+		const problem = icuProblem(dict.df, project.config.defaultLocale ?? "en", locale, keyPath, value);
+		if (problem) {
+			result.rejected.push(`${locale}:${key} (${problem})`);
+			continue;
+		}
+		const outcome = setString(dict.df, locale, keyPath, value);
+		if (outcome === "skipped") result.skipped.push(`${locale}:${key}`);
+		else {
+			result[outcome]++;
+			touched.add(dict.rel);
+		}
+	}
+	for (const dict of project.dictionaries) if (touched.has(dict.rel)) await saveDictionaryFile(dict.df);
+	logger.success(`Imported ${result.created + result.updated} value${result.created + result.updated === 1 ? "" : "s"} (${result.created} added, ${result.updated} updated)`);
+	if (result.unknown.length > 0) logger.warn(`${result.unknown.length} unknown key${result.unknown.length === 1 ? "" : "s"} ignored (use --allow-new to add): ${result.unknown.slice(0, 5).join(", ")}${result.unknown.length > 5 ? ", ..." : ""}`);
+	if (result.rejected.length > 0) logger.warn(`${result.rejected.length} value${result.rejected.length === 1 ? "" : "s"} rejected: ${result.rejected.slice(0, 5).join("; ")}`);
+	if (result.skipped.length > 0) logger.warn(`${result.skipped.length} non-text value${result.skipped.length === 1 ? "" : "s"} left unchanged: ${result.skipped.slice(0, 5).join(", ")}`);
+	return result;
+}
+//#endregion
+//#region src/translate/placeholders.ts
+/** `{name}`, `%s` / `%1$d`, and HTML/XML tags: text that must survive translation unchanged. */
+const PLACEHOLDER = /\{[^{}]+\}|%\d*\$?[sdif]|<\/?[A-Za-z][^<>]*>/g;
+function extractPlaceholders(text) {
+	return text.match(PLACEHOLDER) ?? [];
+}
+/**
+* ICU plural/select messages put translatable text inside `{...}` branches, so brace matching
+* is meaningless for them. Compare the structure instead: the same arguments with the same
+* types, every `select` key and every exact `=N` plural match preserved. A translation may
+* add or drop plural categories (`one`, `few`, ...), because languages need different ones.
+*/
+function preservesIcuStructure(source, translated) {
+	try {
+		const before = getArguments(parseMessage(source));
+		const after = getArguments(parseMessage(translated));
+		if (!(before.length === after.length && before.every((a) => after.some((b) => a.name === b.name && a.type === b.type)))) return false;
+		return before.every((a) => {
+			const other = after.find((b) => b.name === a.name && b.type === a.type);
+			return (a.type === "select" ? a.selectors ?? [] : (a.selectors ?? []).filter((selector) => selector.startsWith("="))).every((selector) => other.selectors?.includes(selector));
+		});
+	} catch {
+		return false;
+	}
+}
+/** True when every placeholder of `source` appears in `translated` (as many times as in the source). */
+function preservesPlaceholders(source, translated) {
+	if (isIcuStructured(source)) return preservesIcuStructure(source, translated);
+	const remaining = extractPlaceholders(translated);
+	for (const placeholder of extractPlaceholders(source)) {
+		const index = remaining.indexOf(placeholder);
+		if (index === -1) return false;
+		remaining.splice(index, 1);
+	}
+	return true;
+}
+//#endregion
+//#region src/commands/translate.ts
+async function runTranslate(options = {}) {
+	const root = options.cwd || process.cwd();
+	const project = await loadProject(root, options.config);
+	const settings = project.config.translate;
+	const provider = options.provider ?? settings?.provider;
+	if (!provider && !options.dryRun) throw new Error("No translate provider configured. Add `translate: { provider: claudeProvider() }` to dialex.config.ts (import it from \"@dialexjs/cli/translate\").");
+	const source = options.source ?? settings?.sourceLocale ?? project.config.defaultLocale ?? "en";
+	const everyLocale = new Set(project.config.locales ?? []);
+	for (const { df } of project.dictionaries) listLocales(df).forEach((l) => everyLocale.add(l));
+	const targets = (options.locale?.length ? options.locale : [...everyLocale]).filter((l) => l !== source);
+	const tasks = [];
+	for (const dict of project.dictionaries) {
+		const sourceLeaves = listLeaves(dict.df, source).filter((leaf) => leaf.kind === "string" && leaf.value !== void 0);
+		for (const locale of targets) {
+			const existing = new Map(listLeaves(dict.df, locale).map((leaf) => [leaf.path.join("\0"), leaf]));
+			for (const leaf of sourceLeaves) {
+				const current = existing.get(leaf.path.join("\0"));
+				if (!current || current.kind === "string" && current.value?.startsWith("[TODO] ")) tasks.push({
+					dict,
+					path: leaf.path,
+					file: dict.rel,
+					locale,
+					key: toKey(dict.name, leaf.path),
+					source: leaf.value
+				});
+			}
+		}
+	}
+	const result = {
+		dryRun: options.dryRun === true,
+		pending: tasks,
+		translated: 0,
+		rejected: []
+	};
+	if (tasks.length === 0) {
+		logger.success(`Nothing to translate from "${source}".`);
+		return result;
+	}
+	if (options.dryRun) {
+		logger.info(`Would translate ${tasks.length} string${tasks.length === 1 ? "" : "s"} from "${source}":`);
+		for (const t of tasks) logger.log(`  ${pc.dim(t.locale)} ${t.key}  ${pc.dim(JSON.stringify(t.source))}`);
+		return result;
+	}
+	const touched = /* @__PURE__ */ new Set();
+	for (const locale of targets) {
+		const localeTasks = tasks.filter((t) => t.locale === locale);
+		if (localeTasks.length === 0) continue;
+		const sendable = provider.supportsIcu ? localeTasks : localeTasks.filter((task) => {
+			if (!isIcuStructured(task.source)) return true;
+			result.rejected.push(`${locale}:${task.key} (provider does not support ICU plural/select messages)`);
+			return false;
+		});
+		if (sendable.length === 0) continue;
+		const unique = [...new Set(sendable.map((t) => t.source))];
+		logger.info(`Translating ${unique.length} string${unique.length === 1 ? "" : "s"} to "${locale}" with ${provider.name ?? "provider"}...`);
+		const translations = await provider.translate(unique, source, locale);
+		if (translations.length !== unique.length) throw new Error(`Provider returned ${translations.length} translations for ${unique.length} strings.`);
+		const byText = new Map(unique.map((text, i) => [text, translations[i]]));
+		for (const task of sendable) {
+			const translated = byText.get(task.source);
+			if (typeof translated !== "string" || translated.trim() === "") {
+				result.rejected.push(`${locale}:${task.key} (empty translation)`);
+				continue;
+			}
+			if (!preservesPlaceholders(task.source, translated)) {
+				result.rejected.push(`${locale}:${task.key} (placeholders changed)`);
+				continue;
+			}
+			if (setString(task.dict.df, locale, task.path, translated) === "skipped") {
+				result.rejected.push(`${locale}:${task.key} (not a text value)`);
+				continue;
+			}
+			task.translated = translated;
+			result.translated++;
+			touched.add(task.dict);
+		}
+	}
+	for (const dict of touched) await saveDictionaryFile(dict.df);
+	logger.success(`Translated ${result.translated} of ${tasks.length} string${tasks.length === 1 ? "" : "s"}.`);
+	if (result.rejected.length > 0) logger.warn(`${result.rejected.length} left unchanged: ${result.rejected.slice(0, 5).join("; ")}${result.rejected.length > 5 ? "; ..." : ""}`);
+	return result;
+}
+//#endregion
+//#region src/index.ts
+const program = new Command();
+program.name("dialex").description("Dialex CLI - High-performance, type-safe internationalization compiler and tooling").version("0.1.0");
+program.command("generate").alias("gen").description("Generate standalone dictionary bundle and TypeScript declarations").option("-w, --watch", "Watch dictionary files for changes").option("-o, --output <path>", "Custom output file path for generated dictionaries").option("-c, --config <path>", "Custom config path").action(async (opts) => {
+	await runGenerate(opts);
+});
+program.command("init").description("Initialize Dialex in the current project").option("-f, --framework <framework>", "Target framework (hono, express, fastify, koa, nestjs, next, react)").option("-d, --default-locale <locale>", "Default locale (e.g. en)").option("-l, --locales <locales>", "Comma-separated supported locales (e.g. en,tr)").option("-y, --yes", "Skip prompts and use defaults").action(async (opts) => {
+	await runInit(opts);
+});
+program.command("check").alias("lint").description("Verify dictionary key parity and locale completeness").option("-c, --config <path>", "Custom config path").option("--json", "Print machine-readable JSON").option("--github", "Print GitHub Actions annotations").option("--fix", "Insert missing keys marked with [TODO]").option("--src <globs...>", "Source globs to scan for dictionary references").action(async (opts) => {
+	await runCheck(opts);
+});
+program.command("export").description("Export dictionary strings for translators (json, csv, or xliff)").option("-f, --format <format>", "Output format: json, csv, xliff", "json").option("-o, --out <dir>", "Output directory", "i18n-export").option("-l, --locale <locales...>", "Limit to these locales").option("-c, --config <path>", "Custom config path").action(async (opts) => {
+	await runExport(opts);
+});
+program.command("import <file>").description("Write translated strings from a json, csv, or xliff file back into dictionaries").option("-f, --format <format>", "Input format (inferred from the extension)").option("-l, --locale <locale>", "Locale for single-locale files").option("--allow-new", "Add keys that do not exist in any locale yet").option("-c, --config <path>", "Custom config path").action(async (file, opts) => {
+	await runImport({
+		file,
+		...opts
+	});
+});
+program.command("translate").description("Fill missing translations with the provider configured in dialex.config.ts").option("-l, --locale <locales...>", "Target locales (default: all configured)").option("-s, --source <locale>", "Source locale (default: translate.sourceLocale or defaultLocale)").option("--dry-run", "List what would be translated without calling the provider").option("-c, --config <path>", "Custom config path").action(async (opts) => {
+	try {
+		await runTranslate(opts);
+	} catch (err) {
+		logger.error(err.message || String(err));
+		process.exit(1);
+	}
+});
+program.parse();
+//#endregion
+export {};
+
+//# sourceMappingURL=index.mjs.map