@dialexjs/cli 0.1.0 → 0.2.1

package/dist/api.d.mts

@@ -57,8 +57,11 @@ interface Leaf {
  * the file does not have an editable shape; throws on syntax errors.
  */
 export declare function parseDictionaryText(file: string, text: string): DictionaryFile | undefined;
+/** Loads a dictionary file; returns `undefined` when its shape is not editable. */
+export declare function loadDictionaryFile(file: string): Promise<DictionaryFile | undefined>;
 /** The source text with all edits applied, without writing anything. */
 export declare function renderDictionaryFile(df: DictionaryFile): string;
+export declare function saveDictionaryFile(df: DictionaryFile): Promise<void>;
 export declare function listLocales(df: DictionaryFile): string[];
 /** Lists every leaf (string, function, or other value) of a locale, in source order. */
 export declare function listLeaves(df: DictionaryFile, locale: string): Leaf[];
@@ -225,5 +228,19 @@ export declare function loadStaticProject(root: string, configFile?: string): Pr
 /** `home` + `["nav", "about"]` -> `home.nav.about` */
 export declare const toKey: (dictionary: string, keyPath: string[]) => string;
 //#endregion
-export type { AnalysisConfig, AnalysisIssue, AnalysisOptions, AnalysisResult, AnalyzedDictionary, DictionaryFile, IssueCode, IssueLevel, Leaf, LeafInfo, LeafKind, Project, ProjectDictionary, Reference, SourceRange, StaticConfig, StaticConfigResult };
+//#region src/commands/generate.d.ts
+interface GenerateOptions {
+  cwd?: string;
+  watch?: boolean;
+  output?: string;
+  config?: string;
+  json?: boolean;
+}
+export declare function generateDictionaries(root: string, options?: GenerateOptions): {
+  files: string[];
+  outputPath: string;
+  dtsPath: string;
+};
+//#endregion
+export type { AnalysisConfig, AnalysisIssue, AnalysisOptions, AnalysisResult, AnalyzedDictionary, DictionaryFile, GenerateOptions, IssueCode, IssueLevel, Leaf, LeafInfo, LeafKind, Project, ProjectDictionary, Reference, SourceRange, StaticConfig, StaticConfigResult };
 //# sourceMappingURL=api.d.mts.map

package/dist/api.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.mts","names":[],"sources":["../src/utils/dictionary-edit.ts","../src/analysis.ts","../src/utils/static-config.ts","../src/utils/project.ts"],"mappings":";;;;;;;;;;;;;;;KAgBK;EAAS;GAAe;;qBAEhB;UAII;EACf;;EAEA;EACA,KAAK,QAAQ,kBAAkB;;EAE/B,YAAY;;EAEZ;;;;;;EAMA;;;UAIe;EACf;IAAS;IAAc;;EACvB;IAAO;IAAc;;;KAGX;UAEK;EACf;EACA,MAAM;;EAEN;;;;;;wBAgIc,oBAAoB,cAAc,eAAe;;wBAyBjD,qBAAqB,IAAI;wBAazB,YAAY,IAAI;;wBAahB,WAAW,IAAI,gBAAgB,iBAAiB;wBAoChD,QAAQ,IAAI,gBAAgB,gBAAgB;wBAI5C,UAAU,IAAI,gBAAgB,gBAAgB;KA+BlD;;;;;wBAMI,UACd,IAAI,gBACJ,gBACA,gBACA,gBACC;;;;;;wBAsBa,SACd,IAAI,gBACJ,oBACA,kBACA,gBACA,aAAa;;;;;wBAwCC,WACd,IAAI,gBACJ,gBACA,kBACC;;wBAMa,mBAAmB,IAAI,iBAAiB;;wBAKxC,cACd,IAAI,gBACJ,gBACA;;;;;;;;;;;KCnXU;KAEA;UAeK;;EAEf;EACA,OAAO;EACP,MAAM;EACN;;EAEA,QAAQ;;EAER;EACA;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;;UAGe;EACf;EACA,QAAQ;;EAER;;EAEA;;EAEA;;EAEA;;UAGe;EACf;EACA;;UAGe;EACf;;EAEA;;EAEA;;EAEA,QAAQ,YAAY,YAAY;;EAEhC;;EAEA,KAAK;;UAGU;EACf,QAAQ;EACR,cAAc;;EAEd;EACA;;qBAKW;UAqBI;;EAEf;EACA;;EAEA;EACA;;;wBAIc,eAAe,eAAe;wBA4IxB,eAAe,SAAS,kBAAkB,QAAQ;;wBA+NxD,aAAa,cAAc;;;;;;;;UCte1B;EACf;EACA;EACA;EACA,WAAW;EACX;EACA;;UAGe;EACf,QAAQ;;EAER;;EAEA;;qBAMW,uBAAuB;;wBAiFpB,kBAAkB,cAAc,gBAA4B;;wBA8C5D,iBAAiB,cAAc,sBAAsB;;;UC5JpD;;EAEf;EACA;EACA,IAAI;;UAGW;EACf;EACA,QAAQ;EACR,cAAc;;EAEd;;EAEA;;;;;;wBAgCoB,YAAY,cAAc,sBAAsB,QAAQ;;;;;wBASxD,kBAAkB,cAAc,sBAAsB,QAAQ;;qBAMvE,QAAK,oBAAsB"}
+{"version":3,"file":"api.d.mts","names":[],"sources":["../src/utils/dictionary-edit.ts","../src/analysis.ts","../src/utils/static-config.ts","../src/utils/project.ts","../src/commands/generate.ts"],"mappings":";;;;;;;;;;;;;;;KAgBK;EAAS;GAAe;;qBAEhB;UAII;EACf;;EAEA;EACA,KAAK,QAAQ,kBAAkB;;EAE/B,YAAY;;EAEZ;;;;;;EAMA;;;UAIe;EACf;IAAS;IAAc;;EACvB;IAAO;IAAc;;;KAGX;UAEK;EACf;EACA,MAAM;;EAEN;;;;;;wBAgIc,oBAAoB,cAAc,eAAe;;wBAoB3C,mBAAmB,eAAe,QAAQ;;wBAKhD,qBAAqB,IAAI;wBAKnB,mBAAmB,IAAI,iBAAiB;wBAQ9C,YAAY,IAAI;;wBAahB,WAAW,IAAI,gBAAgB,iBAAiB;wBAoChD,QAAQ,IAAI,gBAAgB,gBAAgB;wBAI5C,UAAU,IAAI,gBAAgB,gBAAgB;KA+BlD;;;;;wBAMI,UACd,IAAI,gBACJ,gBACA,gBACA,gBACC;;;;;;wBAsBa,SACd,IAAI,gBACJ,oBACA,kBACA,gBACA,aAAa;;;;;wBAwCC,WACd,IAAI,gBACJ,gBACA,kBACC;;wBAMa,mBAAmB,IAAI,iBAAiB;;wBAKxC,cACd,IAAI,gBACJ,gBACA;;;;;;;;;;;KCnXU;KAEA;UAeK;;EAEf;EACA,OAAO;EACP,MAAM;EACN;;EAEA,QAAQ;;EAER;EACA;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;;UAGe;EACf;EACA,QAAQ;;EAER;;EAEA;;EAEA;;EAEA;;UAGe;EACf;EACA;;UAGe;EACf;;EAEA;;EAEA;;EAEA,QAAQ,YAAY,YAAY;;EAEhC;;EAEA,KAAK;;UAGU;EACf,QAAQ;EACR,cAAc;;EAEd;EACA;;qBAKW;UAqBI;;EAEf;EACA;;EAEA;EACA;;;wBAIc,eAAe,eAAe;wBA4IxB,eAAe,SAAS,kBAAkB,QAAQ;;wBA+NxD,aAAa,cAAc;;;;;;;;UCte1B;EACf;EACA;EACA;EACA,WAAW;EACX;EACA;;UAGe;EACf,QAAQ;;EAER;;EAEA;;qBAMW,uBAAuB;;wBAiFpB,kBAAkB,cAAc,gBAA4B;;wBA8C5D,iBAAiB,cAAc,sBAAsB;;;UC5JpD;;EAEf;EACA;EACA,IAAI;;UAGW;EACf;EACA,QAAQ;EACR,cAAc;;EAEd;;EAEA;;;;;;wBAgCoB,YAAY,cAAc,sBAAsB,QAAQ;;;;;wBASxD,kBAAkB,cAAc,sBAAsB,QAAQ;;qBAMvE,QAAK,oBAAsB;;;UC7DvB;EACf;EACA;EACA;EACA;EACA;;wBAGc,qBACd,cACA,UAAS;EAET;EACA;EACA"}

package/dist/api.mjs

@@ -1,2 +1,2 @@
-import { S as renderDictionaryFile, _ as listLeaves, a as parseStaticConfig, b as locationOf, c as analyzeProject, d as TODO_PREFIX, f as copyLeaf, g as hasPath, h as getString, i as DEFAULT_STATIC_CONFIG, l as relativeFile, m as getLeafSource, n as loadStaticProject, o as readStaticConfig, p as dictionaryLocation, r as toKey, s as DEFAULT_SOURCE_GLOB, t as loadProject, u as scanReferences, v as listLocales, w as setString, x as parseDictionaryText } from "./project-D4PmfqxM.mjs";
-export { DEFAULT_SOURCE_GLOB, DEFAULT_STATIC_CONFIG, TODO_PREFIX, analyzeProject, copyLeaf, dictionaryLocation, getLeafSource, getString, hasPath, listLeaves, listLocales, loadProject, loadStaticProject, locationOf, parseDictionaryText, parseStaticConfig, readStaticConfig, relativeFile, renderDictionaryFile, scanReferences, setString, toKey };
+import { C as saveDictionaryFile, S as renderDictionaryFile, T as generateDictionaries, _ as listLeaves, a as parseStaticConfig, b as locationOf, c as analyzeProject, d as TODO_PREFIX, f as copyLeaf, g as hasPath, h as getString, i as DEFAULT_STATIC_CONFIG, l as relativeFile, m as getLeafSource, n as loadStaticProject, o as readStaticConfig, p as dictionaryLocation, r as toKey, s as DEFAULT_SOURCE_GLOB, t as loadProject, u as scanReferences, v as listLocales, w as setString, x as parseDictionaryText, y as loadDictionaryFile } from "./project-gkFBurqG.mjs";
+export { DEFAULT_SOURCE_GLOB, DEFAULT_STATIC_CONFIG, TODO_PREFIX, analyzeProject, copyLeaf, dictionaryLocation, generateDictionaries, getLeafSource, getString, hasPath, listLeaves, listLocales, loadDictionaryFile, loadProject, loadStaticProject, locationOf, parseDictionaryText, parseStaticConfig, readStaticConfig, relativeFile, renderDictionaryFile, saveDictionaryFile, scanReferences, setString, toKey };

package/dist/index.mjs

@@ -1,109 +1,15 @@
 #!/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 { C as saveDictionaryFile, D as logger, E as runGenerate, T as generateDictionaries, _ 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-gkFBurqG.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 { 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
@@ -310,6 +216,13 @@ async function runInit(options = {}) {
 			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");
@@ -410,6 +323,62 @@ ${localeList.map((loc) => `  ${loc}: {
 			logger.success("Added \"i18n:generate\" script to package.json");
 		}
 	} catch {}
+	if (options.ai === true || options.yes && options.ai !== false && options.noAi !== true) try {
+		const claudeSkillDir = path.join(root, ".claude/skills/dialex");
+		fs.mkdirSync(claudeSkillDir, { recursive: true });
+		fs.writeFileSync(path.join(claudeSkillDir, "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 \`dialex generate\` or \`npm run i18n: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 (.claude/skills, .mcp.json, AGENTS.md)");
+	} catch (err) {
+		logger.warn(`Could not finish AI configuration: ${err.message || String(err)}`);
+	}
 	logger.log("");
 	logger.info(pc.bold(`Quick start for ${framework.toUpperCase()}:`));
 	switch (framework) {
@@ -764,15 +733,21 @@ ${units.join("\n")}
 `);
 		}
 	}
-	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 {
+	const quiet = options.json === true;
+	const result = {
+		success: true,
 		files,
 		keys: orderedKeys.size,
 		skippedFunctions,
 		skippedFiles: project.unsupported
 	};
+	if (quiet) console.log(JSON.stringify(result, null, 2));
+	else {
+		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 result;
 }
 //#endregion
 //#region src/commands/import.ts
@@ -891,7 +866,9 @@ async function runImport(options) {
 	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 quiet = options.json === true;
 	const result = {
+		success: true,
 		created: 0,
 		updated: 0,
 		skipped: [],
@@ -924,10 +901,14 @@ async function runImport(options) {
 		}
 	}
 	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(", ")}`);
+	if (result.rejected.length > 0) result.success = false;
+	if (quiet) console.log(JSON.stringify(result, null, 2));
+	else {
+		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
@@ -997,19 +978,25 @@ async function runTranslate(options = {}) {
 			}
 		}
 	}
+	const quiet = options.json === true;
 	const result = {
+		success: true,
 		dryRun: options.dryRun === true,
 		pending: tasks,
 		translated: 0,
 		rejected: []
 	};
 	if (tasks.length === 0) {
-		logger.success(`Nothing to translate from "${source}".`);
+		if (quiet) console.log(JSON.stringify(result, null, 2));
+		else 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))}`);
+		if (quiet) console.log(JSON.stringify(result, null, 2));
+		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))}`);
+		}
 		return result;
 	}
 	const touched = /* @__PURE__ */ new Set();
@@ -1023,7 +1010,7 @@ async function runTranslate(options = {}) {
 		});
 		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"}...`);
+		if (!quiet) 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]]));
@@ -1047,37 +1034,45 @@ async function runTranslate(options = {}) {
 		}
 	}
 	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 ? "; ..." : ""}`);
+	if (result.rejected.length > 0) result.success = false;
+	if (quiet) console.log(JSON.stringify(result, null, 2));
+	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 ? "; ..." : ""}`);
+	}
 	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) => {
+program.name("dialex").description("Dialex CLI - High-performance, type-safe internationalization compiler and tooling").version("0.2.1");
+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").action(async (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 (.claude/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("--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) => {
+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").option("--json", "Print machine-readable JSON").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) => {
+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").option("--json", "Print machine-readable JSON").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) => {
+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").option("--json", "Print machine-readable JSON").action(async (opts) => {
 	try {
 		await runTranslate(opts);
 	} catch (err) {
-		logger.error(err.message || String(err));
+		if (opts.json) console.log(JSON.stringify({
+			success: false,
+			error: err.message || String(err)
+		}, null, 2));
+		else logger.error(err.message || String(err));
 		process.exit(1);
 	}
 });