@dialexjs/cli 0.7.2 → 0.9.2

package/dist/index.mjs

@@ -1,27 +1,18 @@
 #!/usr/bin/env node
-import { A as scanFiles, C as lockPath, E as writeLock, F as getString, I as hasPath, L as listLeaves, M as copyLeaf, R as listLocales, S as lockFor, T as record, U as saveDictionaryFile, W as setString, a as renderGenerated, d as resolveDialexConfig, f as logger, i as generateDictionaries, j as TODO_PREFIX, m as analyzeProject, o as runGenerate, r as toKey, t as loadProject, w as readLock, x as isStale, y as LOCK_FILE, z as loadDictionaryFile } from "./project-Dz0FbydQ.mjs";
+import { A as scanFiles, B as listLeaves, C as lockPath, E as writeLock, G as saveDictionaryFile, H as loadDictionaryFile, I as copyLeaf, K as TODO_PREFIX, L as setString, R as getString, S as lockFor, T as record, V as listLocales, a as generateDictionaries, d as resolveDialexConfig, f as logger, i as runGenerate, p as analyzeProject, r as toKey, s as renderGenerated, t as loadProject, w as readLock, x as isStale, y as LOCK_FILE, z as hasPath } from "./project-BTpZGNjh.mjs";
 import { Command } from "commander";
-import fs from "node:fs";
 import path from "node:path";
 import pc from "picocolors";
-import { fileURLToPath } from "node:url";
+import fs from "node:fs";
 import { loadFile, parseModule, writeFile } from "magicast";
+import { fileURLToPath } from "node:url";
 import { argumentSignature, getArguments, isIcuStructured, parseMessage } from "dialexjs/icu";
 import * as p from "@clack/prompts";
 import { addNuxtModule } from "magicast/helpers";
 //#region package.json
-var version = "0.7.2";
+var version = "0.9.2";
 //#endregion
-//#region src/commands/check.ts
-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
-	});
-}
+//#region src/commands/check/fix.ts
 /**
 * 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.
@@ -49,9 +40,22 @@ async function applyFixes(files, configuredLocales, defaultLocale) {
 	}
 	return fixed;
 }
+//#endregion
+//#region src/commands/check/report.ts
+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
+	});
+}
 function escapeAnnotation(value) {
 	return value.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
 }
+//#endregion
+//#region src/commands/check/stale-generated.ts
 /**
 * What a formatter (Prettier, Biome, oxfmt) can change without changing the code: whitespace,
 * quote style, quoted object keys and trailing commas. Comparing this form keeps `check` quiet
@@ -108,6 +112,8 @@ function staleGeneratedFiles(root, options) {
 		rewritten
 	};
 }
+//#endregion
+//#region src/commands/check/index.ts
 async function runCheck(options = {}) {
 	const root = options.cwd || process.cwd();
 	const quiet = options.json === true;
@@ -300,7 +306,7 @@ ${units.join("\n")}
 	return result;
 }
 //#endregion
-//#region src/commands/import.ts
+//#region src/commands/import/formats.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 = [];
@@ -383,6 +389,8 @@ function inferFormat(file) {
 	if (ext === ".xlf" || ext === ".xliff") return "xliff";
 	throw new Error(`Cannot infer format from "${ext}". Pass --format json|csv|xliff.`);
 }
+//#endregion
+//#region src/commands/import/icu-guard.ts
 /**
 * 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.
@@ -408,6 +416,8 @@ function icuProblem(df, defaultLocale, locale, keyPath, value) {
 		}
 	}
 }
+//#endregion
+//#region src/commands/import/index.ts
 async function runImport(options) {
 	const root = options.cwd || process.cwd();
 	const file = path.resolve(root, options.file);
@@ -510,6 +520,16 @@ function detectFramework(root) {
 			confidence: "high",
 			matchedRule: "package.json dependencies (@nestjs/core)"
 		};
+		if ("@adonisjs/core" in allDeps) return {
+			framework: "adonis",
+			confidence: "high",
+			matchedRule: "package.json dependencies (@adonisjs/core)"
+		};
+		if ("@hapi/hapi" in allDeps) return {
+			framework: "hapi",
+			confidence: "high",
+			matchedRule: "package.json dependencies (@hapi/hapi)"
+		};
 		if ("fastify" in allDeps) return {
 			framework: "fastify",
 			confidence: "high",
@@ -535,11 +555,51 @@ function detectFramework(root) {
 			confidence: "high",
 			matchedRule: "package.json dependencies (hono)"
 		};
+		if ("@trpc/server" in allDeps) return {
+			framework: "trpc",
+			confidence: "high",
+			matchedRule: "package.json dependencies (@trpc/server)"
+		};
+		if ("@builder.io/qwik" in allDeps) return {
+			framework: "qwik",
+			confidence: "high",
+			matchedRule: "package.json dependencies (@builder.io/qwik)"
+		};
+		if ("react-native" in allDeps || "expo" in allDeps) return {
+			framework: "react-native",
+			confidence: "high",
+			matchedRule: "package.json dependencies (react-native/expo)"
+		};
+		if ("@react-router/dev" in allDeps) return {
+			framework: "react-router",
+			confidence: "high",
+			matchedRule: "package.json dependencies (@react-router/dev)"
+		};
+		if ("solid-js" in allDeps) return {
+			framework: "solid",
+			confidence: "high",
+			matchedRule: "package.json dependencies (solid-js)"
+		};
+		if ("svelte" in allDeps) return {
+			framework: "svelte",
+			confidence: "high",
+			matchedRule: "package.json dependencies (svelte)"
+		};
 		if ("vue" in allDeps && !("react" in allDeps)) return {
 			framework: "vue",
 			confidence: "high",
 			matchedRule: "package.json dependencies (vue)"
 		};
+		if ("preact" in allDeps) return {
+			framework: "preact",
+			confidence: "high",
+			matchedRule: "package.json dependencies (preact)"
+		};
+		if ("lit" in allDeps && !("react" in allDeps)) return {
+			framework: "lit",
+			confidence: "high",
+			matchedRule: "package.json dependencies (lit)"
+		};
 		if ("react" in allDeps || "vite" in allDeps) return {
 			framework: "react",
 			confidence: "high",
@@ -554,7 +614,8 @@ function detectFramework(root) {
 	for (const [framework, base] of [
 		["nuxt", "nuxt.config"],
 		["sveltekit", "svelte.config"],
-		["astro", "astro.config"]
+		["astro", "astro.config"],
+		["react-router", "react-router.config"]
 	]) if ([
 		"js",
 		"mjs",
@@ -576,6 +637,125 @@ function detectFramework(root) {
 	};
 }
 //#endregion
+//#region src/commands/init/ai-setup.ts
+/** Writes `.agents/skills/dialex/SKILL.md`, merges `.mcp.json` and adds a note to AGENTS.md. */
+function setupAiSupport(root) {
+	try {
+		const skillDir = path.join(root, ".agents/skills/dialex");
+		fs.mkdirSync(skillDir, { recursive: true });
+		fs.writeFileSync(path.join(skillDir, "SKILL.md"), `---
+name: dialex
+description: Guide for internationalizing JavaScript and TypeScript apps with Dialex. Use when adding translations, creating content dictionaries, configuring locales, or using Dialex with frameworks like Next.js, React, Express, Hono, Fastify, SvelteKit, and Nuxt.
+---
+
+# Dialex Internationalization
+
+Dialex is a high-performance, type-safe internationalization toolchain for JavaScript and TypeScript.
+
+## Core Concepts
+- Dictionaries are defined with \`defineDictionary("name", { ... })\` in \`*.content.ts\` files.
+- Keys must match across all locales.
+- ICU message syntax is supported for plurals and selects.
+- Parity is validated at compile time with \`dialex check\`.
+
+## Useful Commands
+- \`dialex check --json\`: Check dictionary parity and references.
+- \`dialex check --fix\`: Automatically insert missing keys marked with [TODO].
+- \`dialex generate\`: Rebuild standalone dictionary bundle and types.
+- \`dialex translate --locale <locale>\`: Automatically translate missing keys.
+`, "utf-8");
+		const mcpConfigPath = path.join(root, ".mcp.json");
+		let mcpConfig = {};
+		if (fs.existsSync(mcpConfigPath)) try {
+			mcpConfig = JSON.parse(fs.readFileSync(mcpConfigPath, "utf-8"));
+		} catch {
+			mcpConfig = {};
+		}
+		mcpConfig.mcpServers = mcpConfig.mcpServers || {};
+		mcpConfig.mcpServers.dialex = mcpConfig.mcpServers.dialex || {
+			command: "npx",
+			args: ["@dialexjs/mcp"]
+		};
+		fs.writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2) + "\n", "utf-8");
+		const agentsMdPath = path.join(root, "AGENTS.md");
+		const dialexAgentSnippet = `
+## Internationalization (Dialex)
+
+This project uses [Dialex](https://github.com/awaiden/dialex) for type-safe internationalization.
+- Dictionaries are in \`*.content.ts\` files using \`defineDictionary\`.
+- Run \`dialex check --json\` to verify parity.
+- Run \`dialex check --fix\` to insert missing keys marked with \`[TODO]\`.
+- Run \`dx generate\` (alias of \`dialex\`) or \`npm run dx:generate\` to compile dictionary bundles and update types.
+`;
+		if (!fs.existsSync(agentsMdPath)) fs.writeFileSync(agentsMdPath, dialexAgentSnippet.trimStart(), "utf-8");
+		else {
+			const existing = fs.readFileSync(agentsMdPath, "utf-8");
+			if (!existing.includes("Dialex")) fs.writeFileSync(agentsMdPath, existing.trimEnd() + "\n" + dialexAgentSnippet, "utf-8");
+		}
+		logger.success("Configured AI assistant support (.agents/skills, .mcp.json, AGENTS.md)");
+	} catch (err) {
+		logger.warn(`Could not finish AI configuration: ${err.message || String(err)}`);
+	}
+}
+//#endregion
+//#region src/commands/init/config-file.ts
+/** Creates `dialex.config.ts`, or updates the locales of the one that exists. */
+async function writeDialexConfig(root, framework, defaultLocale, localeList) {
+	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);
+	const generatedOutput = framework === "react-router" ? "app/dialex.generated.ts" : framework === "adonis" ? "start/dialex.generated.ts" : void 0;
+	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;
+					if (generatedOutput) mod.exports.default.$args[0].output = generatedOutput;
+				}
+				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;
+			if (generatedOutput) mod.exports.default.$args[0].output = generatedOutput;
+			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(", ")}],${generatedOutput ? `\n  output: "${generatedOutput}",` : ""}
+});
+`;
+		fs.writeFileSync(configPath, fallback, "utf-8");
+	}
+}
+/** Nuxt reads the generated file through its module; it has to be registered in the Nuxt config. */
+async function registerNuxtModule(root) {
+	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", {});
+		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.");
+	}
+}
+//#endregion
 //#region src/utils/package-json.ts
 /** Version of this CLI, which the other Dialex packages share. Read from the nearest package.json. */
 function cliVersion() {
@@ -627,184 +807,9 @@ function addRequiredPackages(pkg, version = cliVersion()) {
 	return added;
 }
 //#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();
-		if (options.ai === void 0 && options.noAi === void 0) {
-			const confirmAi = await p.confirm({
-				message: "Configure AI agent support (Claude/Cursor skills, .mcp.json, AGENTS.md)?",
-				initialValue: true
-			});
-			if (!p.isCancel(confirmAi)) options.ai = confirmAi;
-		}
-	} 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 === "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", {});
-			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!");
+//#region src/commands/init/dependencies.ts
+/** Adds `dialexjs` and `@dialexjs/cli` to package.json, and the `dx:generate` script. */
+function updatePackageJson(root) {
 	const pkgPath = path.join(root, "package.json");
 	if (fs.existsSync(pkgPath)) try {
 		const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
@@ -822,139 +827,155 @@ ${localeList.map((loc) => `  ${loc}: {
 		logger.warn("Could not update package.json; add dialexjs and @dialexjs/cli manually.");
 	}
 	else logger.warn("No package.json found; install dialexjs and @dialexjs/cli in your project.");
-	if (options.ai === true || options.yes && options.ai !== false && options.noAi !== true) try {
-		const skillDir = path.join(root, ".agents/skills/dialex");
-		fs.mkdirSync(skillDir, { recursive: true });
-		fs.writeFileSync(path.join(skillDir, "SKILL.md"), `---
-name: dialex
-description: Guide for internationalizing JavaScript and TypeScript apps with Dialex. Use when adding translations, creating content dictionaries, configuring locales, or using Dialex with frameworks like Next.js, React, Express, Hono, Fastify, SvelteKit, and Nuxt.
----
-
-# Dialex Internationalization
-
-Dialex is a high-performance, type-safe internationalization toolchain for JavaScript and TypeScript.
-
-## Core Concepts
-- Dictionaries are defined with \`defineDictionary("name", { ... })\` in \`*.content.ts\` files.
-- Keys must match across all locales.
-- ICU message syntax is supported for plurals and selects.
-- Parity is validated at compile time with \`dialex check\`.
-
-## Useful Commands
-- \`dialex check --json\`: Check dictionary parity and references.
-- \`dialex check --fix\`: Automatically insert missing keys marked with [TODO].
-- \`dialex generate\`: Rebuild standalone dictionary bundle and types.
-- \`dialex translate --locale <locale>\`: Automatically translate missing keys.
-`, "utf-8");
-		const mcpConfigPath = path.join(root, ".mcp.json");
-		let mcpConfig = {};
-		if (fs.existsSync(mcpConfigPath)) try {
-			mcpConfig = JSON.parse(fs.readFileSync(mcpConfigPath, "utf-8"));
-		} catch {
-			mcpConfig = {};
-		}
-		mcpConfig.mcpServers = mcpConfig.mcpServers || {};
-		mcpConfig.mcpServers.dialex = mcpConfig.mcpServers.dialex || {
-			command: "npx",
-			args: ["@dialexjs/mcp"]
-		};
-		fs.writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2) + "\n", "utf-8");
-		const agentsMdPath = path.join(root, "AGENTS.md");
-		const dialexAgentSnippet = `
-## Internationalization (Dialex)
-
-This project uses [Dialex](https://github.com/awaiden/dialex) for type-safe internationalization.
-- Dictionaries are in \`*.content.ts\` files using \`defineDictionary\`.
-- Run \`dialex check --json\` to verify parity.
-- Run \`dialex check --fix\` to insert missing keys marked with \`[TODO]\`.
-- Run \`dx generate\` (alias of \`dialex\`) or \`npm run dx:generate\` to compile dictionary bundles and update types.
-`;
-		if (!fs.existsSync(agentsMdPath)) fs.writeFileSync(agentsMdPath, dialexAgentSnippet.trimStart(), "utf-8");
-		else {
-			const existing = fs.readFileSync(agentsMdPath, "utf-8");
-			if (!existing.includes("Dialex")) fs.writeFileSync(agentsMdPath, existing.trimEnd() + "\n" + dialexAgentSnippet, "utf-8");
-		}
-		logger.success("Configured AI assistant support (.agents/skills, .mcp.json, AGENTS.md)");
-	} catch (err) {
-		logger.warn(`Could not finish AI configuration: ${err.message || String(err)}`);
+}
+//#endregion
+//#region src/commands/init/prompts.ts
+/** The frameworks `dialex init` offers, in the order of the prompt: value and label. */
+const FRAMEWORKS = [
+	["hono", "Hono"],
+	["express", "Express"],
+	["fastify", "Fastify"],
+	["koa", "Koa"],
+	["nestjs", "NestJS"],
+	["next", "Next.js"],
+	["react", "React / Vite"],
+	["elysia", "Elysia"],
+	["sveltekit", "SvelteKit"],
+	["astro", "Astro"],
+	["vue", "Vue / Vite"],
+	["nuxt", "Nuxt"],
+	["svelte", "Svelte / Vite"],
+	["solid", "Solid / Vite"],
+	["react-router", "React Router"],
+	["react-native", "React Native / Expo"],
+	["preact", "Preact / Vite"],
+	["qwik", "Qwik"],
+	["lit", "Lit / Web Components"],
+	["hapi", "Hapi"],
+	["adonis", "AdonisJS"],
+	["trpc", "tRPC"]
+];
+/**
+* Asks for the framework, the locales and (when not decided by a flag) AI support. Returns
+* `undefined` when the user cancels. May set `options.ai`.
+*/
+async function askInit(options, detected) {
+	p.intro(pc.bgCyan(pc.black(" dialex init ")));
+	const frameworkOptions = FRAMEWORKS.map(([value, label]) => ({
+		value,
+		label,
+		hint: detected.framework === value ? "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;
 	}
-	logger.log("");
-	logger.info(pc.bold(`Quick start for ${framework.toUpperCase()}:`));
-	switch (framework) {
-		case "hono":
-			logger.log(`
+	const 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;
+	}
+	const 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;
+	}
+	const localesInput = inputLocales.trim();
+	if (options.ai === void 0 && options.noAi === void 0) {
+		const confirmAi = await p.confirm({
+			message: "Configure AI agent support (Claude/Cursor skills, .mcp.json, AGENTS.md)?",
+			initialValue: true
+		});
+		if (!p.isCancel(confirmAi)) options.ai = confirmAi;
+	}
+	return {
+		framework,
+		defaultLocale,
+		localesInput
+	};
+}
+//#endregion
+//#region src/commands/init/quickstart.ts
+/** What `dialex init` prints for each framework, after the files are written. */
+const SNIPPETS = {
+	hono: `
 import { Hono } from "hono";
-import { dialex } from "dialexjs/hono";
-import dictionaries from "./src/dialex.generated.js";
+import { dialexHono } from "dialexjs/hono";
+import { dialex } from "./src/dialex.generated.js";
 
 const app = new Hono();
-app.use("*", dialex({ dictionaries }));
+app.use("*", dialexHono({ ...dialex }));
 
 app.get("/", (c) => {
   const dict = c.var.getDictionary("home");
   return c.json({ title: dict.title });
 });
-`);
-			break;
-		case "fastify":
-			logger.log(`
+`,
+	fastify: `
 import Fastify from "fastify";
 import { dialexPlugin } from "dialexjs/fastify";
-import dictionaries from "./src/dialex.generated.js";
+import { dialex } from "./src/dialex.generated.js";
 
 const app = Fastify();
-await app.register(dialexPlugin, { dictionaries });
+await app.register(dialexPlugin, { ...dialex });
 
 app.get("/", (req) => {
   const dict = req.getDictionary("home");
   return { title: dict.title };
 });
-`);
-			break;
-		case "express":
-			logger.log(`
+`,
+	express: `
 import express from "express";
-import { dialex } from "dialexjs/express";
-import dictionaries from "./src/dialex.generated.js";
+import { dialexExpress } from "dialexjs/express";
+import { dialex } from "./src/dialex.generated.js";
 
 const app = express();
-app.use(dialex({ dictionaries }));
+app.use(dialexExpress({ ...dialex }));
 
 app.get("/", (req, res) => {
   const dict = req.getDictionary("home");
   res.json({ title: dict.title });
 });
-`);
-			break;
-		case "koa":
-			logger.log(`
+`,
+	koa: `
 import Koa from "koa";
-import { dialex } from "dialexjs/koa";
-import dictionaries from "./src/dialex.generated.js";
+import { dialexKoa } from "dialexjs/koa";
+import { dialex } from "./src/dialex.generated.js";
 
 const app = new Koa();
-app.use(dialex({ dictionaries }));
+app.use(dialexKoa({ ...dialex }));
 
 app.use((ctx) => {
   const dict = ctx.getDictionary("home");
   ctx.body = { title: dict.title };
 });
-`);
-			break;
-		case "nestjs":
-			logger.log(`
+`,
+	nestjs: `
 import { Module } from "@nestjs/common";
 import { DialexModule } from "dialexjs/nestjs";
-import dictionaries from "./src/dialex.generated.js";
+import { dialex } from "./src/dialex.generated.js";
 
 @Module({
-  imports: [DialexModule.forRoot({ dictionaries })],
+  imports: [DialexModule.forRoot({ ...dialex })],
 })
 export class AppModule {}
-`);
-			break;
-		case "next":
-			logger.log(`
+`,
+	next: `
 // src/dialex.ts
 import { createDialexServer } from "dialexjs/server";
 import { dialex } from "./dialex.generated";
@@ -975,10 +996,8 @@ export default async function Page({ params }: { params: Promise<{ locale: strin
 //   import { DialexProvider } from "dialexjs/react";
 //   import { dialex } from "./dialex.generated";
 //   export const Providers = ({ children }) => <DialexProvider {...dialex}>{children}</DialexProvider>;
-`);
-			break;
-		case "react":
-			logger.log(`
+`,
+	react: `
 // src/main.tsx
 import { createRoot } from "react-dom/client";
 import { DialexProvider } from "dialexjs/react";
@@ -992,45 +1011,37 @@ createRoot(document.getElementById("root")!).render(
 );
 
 // In components: const dict = useDictionary("home")
-`);
-			break;
-		case "elysia":
-			logger.log(`
+`,
+	elysia: `
 import { Elysia } from "elysia";
-import { dialex } from "dialexjs/elysia";
-import dictionaries from "./src/dialex.generated.js";
+import { dialexElysia } from "dialexjs/elysia";
+import { dialex } from "./src/dialex.generated.js";
 
 new Elysia()
-  .use(dialex({ dictionaries }))
+  .use(dialexElysia({ ...dialex }))
   .get("/", ({ getDictionary }) => ({ title: getDictionary("home").title }))
   .listen(3000);
-`);
-			break;
-		case "sveltekit":
-			logger.log(`
+`,
+	sveltekit: `
 // src/hooks.server.ts
 import { dialexHandle } from "dialexjs/sveltekit";
-import dictionaries from "./dialex.generated.js";
+import { dialex } from "./dialex.generated.js";
 
-export const handle = dialexHandle({ dictionaries });
+export const handle = dialexHandle({ ...dialex });
 
 // src/app.html: <html lang="%dialex.lang%">
 // In load functions: locals.getDictionary("home")
-`);
-			break;
-		case "astro":
-			logger.log(`
+`,
+	astro: `
 // src/middleware.ts
-import { dialex } from "dialexjs/astro";
-import dictionaries from "./dialex.generated.js";
+import { dialexAstro } from "dialexjs/astro";
+import { dialex } from "./dialex.generated.js";
 
-export const onRequest = dialex({ dictionaries });
+export const onRequest = dialexAstro({ ...dialex });
 
 // In pages: Astro.locals.getDictionary("home")
-`);
-			break;
-		case "vue":
-			logger.log(`
+`,
+	vue: `
 // src/main.ts
 import { createApp } from "vue";
 import { createDialex } from "dialexjs/vue";
@@ -1040,23 +1051,243 @@ import App from "./App.vue";
 createApp(App).use(createDialex({ ...dialex })).mount("#app");
 
 // In components: const dict = useDictionary("home")
-`);
-			break;
-		case "nuxt":
-			logger.log(`
+`,
+	svelte: `
+<!-- src/App.svelte -->
+<script lang="ts">
+  import { provideDialex, useDictionary } from "dialexjs/svelte";
+  import { dialex } from "./dialex.generated";
+
+  const { locale, setLocale } = provideDialex({ ...dialex });
+  const home = useDictionary("home");
+<\/script>
+
+<h1>{$home.title}</h1>
+<button onclick={() => setLocale("tr")}>TR</button>
+`,
+	solid: `
+// src/index.tsx
+import { render } from "solid-js/web";
+import { DialexProvider } from "dialexjs/solid";
+import { dialex } from "./dialex.generated";
+import App from "./App";
+
+render(
+  () => (
+    <DialexProvider {...dialex}>
+      <App />
+    </DialexProvider>
+  ),
+  document.getElementById("root")!,
+);
+
+// In components: const home = useDictionary("home"); then {home().title}
+`,
+	"react-router": `
+// app/dialex.server.ts
+import { createDialexHandler } from "dialexjs/web";
+import { dialex } from "./dialex.generated";
+
+export const resolveDialex = createDialexHandler({ ...dialex });
+
+// app/root.tsx
+import { DialexProvider } from "dialexjs/react";
+import { useLoaderData } from "react-router";
+import { dialex } from "./dialex.generated";
+import { resolveDialex } from "./dialex.server";
+
+export async function loader({ request }: Route.LoaderArgs) {
+  const { locale } = await resolveDialex(request);
+  return { locale };
+}
+
+export default function App() {
+  const { locale } = useLoaderData<typeof loader>();
+  return (
+    <DialexProvider {...dialex} initialLocale={locale}>
+      <Outlet />
+    </DialexProvider>
+  );
+}
+`,
+	preact: `
+// src/index.tsx
+import { render } from "preact";
+import { DialexProvider } from "dialexjs/preact";
+import { dialex } from "./dialex.generated";
+import { App } from "./app";
+
+render(
+  <DialexProvider {...dialex}>
+    <App />
+  </DialexProvider>,
+  document.getElementById("app")!,
+);
+
+// In components: const dict = useDictionary("home")
+`,
+	qwik: `
+// src/i18n.ts
+import { createDialexQwik } from "dialexjs/qwik";
+import { dialex } from "./dialex.generated";
+
+export const { useDialexProvider, useDialex, setLocale, useDictionary, useT } =
+  createDialexQwik({ ...dialex });
+
+// src/routes/layout.tsx
+export default component$(() => {
+  useDialexProvider();
+  return <Slot />;
+});
+
+// In components: const home = useDictionary("home"); then {home().title}
+`,
+	lit: `
+// src/i18n.ts
+import { createDialex } from "dialexjs/lit";
+import { dialex } from "./dialex.generated";
+
+export const i18n = createDialex({ ...dialex });
+
+// src/my-element.ts
+import { LitElement, html } from "lit";
+import { DialexController } from "dialexjs/lit";
+import { i18n } from "./i18n";
+
+class MyElement extends LitElement {
+  private dx = new DialexController(this, i18n);
+
+  render() {
+    return html\`<h1>\${this.dx.dictionary("home").title}</h1>\`;
+  }
+}
+`,
+	"react-native": `
+// App.tsx
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { getLocales } from "expo-localization";
+import { DialexProvider } from "dialexjs/react-native";
+import { dialex } from "./src/dialex.generated";
+
+export default function App() {
+  return (
+    <DialexProvider
+      {...dialex}
+      deviceLocales={getLocales().map((locale) => locale.languageTag)}
+      storage={AsyncStorage}
+    >
+      <Home />
+    </DialexProvider>
+  );
+}
+
+// In components: const dict = useDictionary("home")
+`,
+	hapi: `
+import Hapi from "@hapi/hapi";
+import { dialexPlugin } from "dialexjs/hapi";
+import { dialex } from "./src/dialex.generated.js";
+
+const server = Hapi.server({ port: 3000 });
+await server.register({ plugin: dialexPlugin, options: { ...dialex } });
+
+server.route({
+  method: "GET",
+  path: "/",
+  handler: (request) => ({ title: request.getDictionary("home").title }),
+});
+`,
+	adonis: `
+// app/middleware/dialex_middleware.ts
+import { createDialexMiddleware } from "dialexjs/adonis";
+import { dialex } from "#start/dialex.generated";
+
+export default createDialexMiddleware({ ...dialex });
+
+// start/kernel.ts
+router.use([() => import("#middleware/dialex_middleware")]);
+
+// In handlers: ctx.locale, ctx.getDictionary("home")
+`,
+	trpc: `
+// src/trpc.ts
+import { initTRPC } from "@trpc/server";
+import { createDialexContext } from "dialexjs/trpc";
+import { dialex } from "./dialex.generated.js";
+
+const resolveDialex = createDialexContext({ ...dialex });
+
+export const createContext = ({ req }: { req: Request }) => ({ ...resolveDialex(req) });
+
+const t = initTRPC.context<Awaited<ReturnType<typeof createContext>>>().create();
+
+export const appRouter = t.router({
+  greeting: t.procedure.query(({ ctx }) => ctx.getDictionary("home").title),
+});
+`,
+	nuxt: `
 // nuxt.config.ts
 export default defineNuxtConfig({
   modules: ["dialexjs/nuxt"],
 });
 
 // In components: const dict = useDictionary("home")
-`);
-			break;
-		default: logger.log(`
+`
+};
+/** Printed for a framework without a snippet of its own. */
+const FALLBACK = `
 Import dictionaries and register your framework middleware to begin!
 Run \`npm run dx:generate\` whenever you add new dictionary files.
-`);
-	}
+`;
+function printQuickstart(framework) {
+	logger.log("");
+	logger.info(pc.bold(`Quick start for ${framework.toUpperCase()}:`));
+	logger.log(Object.hasOwn(SNIPPETS, framework) ? SNIPPETS[framework] : FALLBACK);
+}
+//#endregion
+//#region src/commands/init/starter-dictionary.ts
+/** Writes `home.content.ts` with one entry per locale, unless it is already there. */
+function createStarterDictionary(root, framework, localeList) {
+	const targetDir = (framework === "react-router" || framework === "adonis") && fs.existsSync(path.join(root, "app")) ? path.join(root, "app") : 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.");
+}
+//#endregion
+//#region src/commands/init/index.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) {
+		const answers = await askInit(options, detected);
+		if (!answers) return;
+		({framework, defaultLocale, localesInput} = answers);
+	} 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)]));
+	await writeDialexConfig(root, framework, defaultLocale, localeList);
+	if (framework === "nuxt") await registerNuxtModule(root);
+	createStarterDictionary(root, framework, localeList);
+	generateDictionaries(root, { static: true });
+	logger.success("Generated types and standalone dictionary registry!");
+	updatePackageJson(root);
+	if (options.ai === true || options.yes && options.ai !== false && options.noAi !== true) setupAiSupport(root);
+	printQuickstart(framework);
 	logger.info("Keep dialex.generated.ts current: run `dx generate --watch` while you develop, or use the Dialex VS Code extension, which regenerates on save.");
 	if (isInteractive) p.outro(pc.green("✔ dialex is configured and ready to go!"));
 }
@@ -1150,6 +1381,13 @@ function preservesPlaceholders(source, translated) {
 }
 //#endregion
 //#region src/commands/translate.ts
+/**
+* The JSON of a result. Tasks carry the parsed dictionary and the key path for the writing step;
+* those are not part of the output (the parsed file is large and not meant to be read).
+*/
+function printable(result) {
+	return JSON.stringify(result, (key, value) => key === "dict" || key === "path" ? void 0 : value, 2);
+}
 async function runTranslate(options = {}) {
 	const root = options.cwd || process.cwd();
 	const project = await loadProject(root, options.config);
@@ -1193,12 +1431,12 @@ async function runTranslate(options = {}) {
 		rejected: []
 	};
 	if (tasks.length === 0) {
-		if (quiet) console.log(JSON.stringify(result, null, 2));
+		if (quiet) console.log(printable(result));
 		else logger.success(`Nothing to translate from "${source}".`);
 		return result;
 	}
 	if (options.dryRun) {
-		if (quiet) console.log(JSON.stringify(result, null, 2));
+		if (quiet) console.log(printable(result));
 		else {
 			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))}${t.stale ? pc.yellow("  (out of date)") : ""}`);
@@ -1243,7 +1481,7 @@ async function runTranslate(options = {}) {
 	for (const dict of touched) await saveDictionaryFile(dict.df);
 	if (result.translated > 0) writeLock(root, lock);
 	if (result.rejected.length > 0) result.success = false;
-	if (quiet) console.log(JSON.stringify(result, null, 2));
+	if (quiet) console.log(printable(result));
 	else {
 		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 ? "; ..." : ""}`);
@@ -1257,7 +1495,7 @@ program.name("dialex").description("Dialex CLI - High-performance, type-safe int
 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").option("--json", "Print machine-readable JSON").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").option("--ai", "Configure AI agent support (.agents/skills, .mcp.json, AGENTS.md)").option("--no-ai", "Skip AI agent configuration").action(async (opts) => {
+program.command("init").description("Initialize Dialex in the current project").option("-f, --framework <framework>", "Target framework (hono, express, fastify, koa, nestjs, elysia, sveltekit, astro, vue, nuxt, next, react, react-router, svelte, solid, preact, qwik, lit, react-native, hapi, adonis, trpc)").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").option("--ai", "Configure AI agent support (.agents/skills, .mcp.json, AGENTS.md)").option("--no-ai", "Skip AI agent configuration").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("--fail-on-stale", "Treat translations whose source text changed as errors").option("--src <globs...>", "Source globs to scan for dictionary references").action(async (opts) => {