@contentrain/mcp 0.3.1 → 1.0.3

package/dist/server-CC12z_xq.mjs

@@ -0,0 +1,1868 @@
+import { a as readJson, n as ensureDir, r as pathExists, s as writeJson, t as contentrainDir } from "./fs-BbuGnVcG.mjs";
+import { n as readVocabulary, t as readConfig } from "./config-CPlhDwsv.mjs";
+import { n as readMeta, r as writeMeta } from "./meta-manager-CECrfsKm.mjs";
+import { S as writeContent, _ as resolveMdFilePath, a as fieldDefZodSchema, c as validateModelDefinition, d as listContent, g as resolveLocaleStrategy, h as resolveJsonFilePath, i as deleteModel, l as writeModel, m as resolveContentDir, n as checkReferences, o as listModels, r as countEntries, s as readModel, u as deleteContent } from "./model-manager-sfPdrVIJ.mjs";
+import { t as readContext } from "./context-CRBCTYPB.mjs";
+import { t as detectStack } from "./detect-C8XmJ4S6.mjs";
+import { n as cleanupMergedBranches, t as checkBranchHealth } from "./branch-lifecycle-DB6sgeJi.mjs";
+import { n as listTemplates, t as getTemplate } from "./templates-3HWi-PTu.mjs";
+import { n as createTransaction, t as buildBranchName } from "./transaction-DXkMulzr.mjs";
+import { t as validateProject } from "./validator-C3lZqO3U.mjs";
+import { t as buildGraph } from "./graph-builder-fPrDDwnu.mjs";
+import { n as scanCandidates, r as scanSummary } from "./scanner-BdTiv8sw.mjs";
+import { n as applyExtract, r as applyReuse } from "./apply-manager-BAeqrAHX.mjs";
+import { join } from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { appendFile, readFile, writeFile } from "node:fs/promises";
+import { simpleGit } from "simple-git";
+//#region src/tools/context.ts
+function registerContextTools(server, projectRoot) {
+	server.tool("contentrain_status", "Get full project status (read-only). Returns config, models, context. Do NOT manually edit .contentrain/ based on this output.", {}, async () => {
+		if (!await pathExists(join(contentrainDir(projectRoot), "config.json"))) {
+			const detectedStack = await detectStack(projectRoot);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					initialized: false,
+					detected_stack: detectedStack,
+					suggestion: "Run contentrain_init to set up .contentrain/ structure",
+					next_steps: ["Run contentrain_init"]
+				}, null, 2)
+			}] };
+		}
+		const config = await readConfig(projectRoot);
+		const models = await listModels(projectRoot);
+		const context = await readContext(projectRoot);
+		const vocabulary = await readVocabulary(projectRoot);
+		const errors = [];
+		if (!config) errors.push(".contentrain/config.json missing");
+		const result = {
+			initialized: true,
+			config: config ? {
+				stack: config.stack,
+				workflow: config.workflow,
+				locales: config.locales,
+				domains: config.domains,
+				repository: config.repository
+			} : null,
+			models,
+			context: context ? {
+				lastOperation: context.lastOperation,
+				stats: context.stats
+			} : null,
+			vocabulary_size: vocabulary ? Object.keys(vocabulary.terms).length : 0
+		};
+		if (await pathExists(join(projectRoot, ".git"))) try {
+			const cleanup = await cleanupMergedBranches(projectRoot);
+			const health = await checkBranchHealth(projectRoot);
+			result["branches"] = {
+				total: health.total,
+				merged: health.merged,
+				unmerged: health.unmerged,
+				cleaned_up: cleanup.deleted
+			};
+			if (health.message) result["branch_warning"] = health.message;
+			if (health.blocked) errors.push(health.message);
+		} catch {}
+		if (errors.length > 0) result["validation"] = {
+			errors: errors.length,
+			warnings: 0,
+			summary: errors
+		};
+		const nextSteps = [];
+		if (models.length === 0) nextSteps.push("Create models with contentrain_model_save");
+		if (errors.length > 0) nextSteps.push(`Fix ${errors.length} validation error(s)`);
+		if (nextSteps.length === 0) nextSteps.push("Use contentrain_describe to inspect a model");
+		result["next_steps"] = nextSteps;
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.tool("contentrain_describe", "Get full schema of a single model (read-only). Do NOT manually create content files — use contentrain_content_save instead.", {
+		model: z.string().describe("Model ID (e.g. \"blog-post\", \"hero\")"),
+		include_sample: z.boolean().optional().default(false).describe("Include one sample entry"),
+		locale: z.string().optional().describe("Locale for sample content (default: config default locale)")
+	}, async ({ model: modelId, include_sample, locale }) => {
+		const modelDef = await readModel(projectRoot, modelId);
+		if (!modelDef) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: `Model "${modelId}" not found` })
+			}],
+			isError: true
+		};
+		const config = await readConfig(projectRoot);
+		const effectiveLocale = locale ?? config?.locales.default ?? "en";
+		const stats = await countEntries(projectRoot, modelDef);
+		const result = {
+			id: modelDef.id,
+			name: modelDef.name,
+			kind: modelDef.kind,
+			domain: modelDef.domain,
+			i18n: modelDef.i18n,
+			description: modelDef.description,
+			fields: modelDef.fields,
+			stats: {
+				total_entries: stats.total,
+				locales: stats.locales
+			}
+		};
+		if (include_sample) {
+			const sample = await getSample(projectRoot, modelDef, effectiveLocale);
+			if (sample) result["sample"] = sample;
+		}
+		result["import_snippet"] = generateImportSnippet(modelDef, config?.stack ?? "other", effectiveLocale);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.tool("contentrain_describe_format", "Describes the Contentrain content file format for any language/platform. Returns a comprehensive specification of the file structure, JSON formats, markdown conventions, meta files, and locale strategies.", {}, async () => {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				overview: "Contentrain stores content as plain JSON and Markdown files in a .contentrain/ directory at the project root. All files are committed to git.",
+				directory_structure: {
+					description: "Standard layout of .contentrain/ directory",
+					layout: {
+						".contentrain/config.json": "Project configuration (stack, workflow, locales, domains)",
+						".contentrain/context.json": "Last operation metadata (written by MCP after every write)",
+						".contentrain/vocabulary.json": "Shared vocabulary/terms (optional)",
+						".contentrain/models/{model-id}.json": "Model schema definitions",
+						".contentrain/content/{domain}/{model-id}/": "Content files per model",
+						".contentrain/meta/{model-id}/": "Metadata files per model (status, source, timestamps)"
+					}
+				},
+				model_kinds: {
+					collection: {
+						description: "Multiple entries stored as an object-map keyed by entry ID",
+						storage_format: "JSON object-map: { \"entry-id-1\": { ...fields }, \"entry-id-2\": { ...fields } }",
+						note: "Keys are sorted alphabetically for canonical output. Entry IDs are alphanumeric (1-40 chars, hyphens/underscores allowed).",
+						example: "{ \"abc123\": { \"title\": \"Hello\", \"slug\": \"hello\" }, \"def456\": { \"title\": \"World\", \"slug\": \"world\" } }"
+					},
+					singleton: {
+						description: "Single entry (e.g. site settings, hero section)",
+						storage_format: "JSON object with field key-value pairs: { \"title\": \"My Site\", \"description\": \"...\" }"
+					},
+					document: {
+						description: "Markdown files with YAML-like frontmatter",
+						storage_format: "Markdown file: ---\\nslug: my-post\\ntitle: My Post\\n---\\n\\nMarkdown body content here.",
+						frontmatter_rules: [
+							"Delimited by --- on its own line",
+							"Key-value pairs: key: value",
+							"Arrays: key:\\n  - item1\\n  - item2",
+							"Inline arrays: key: [item1, item2]",
+							"Values auto-parsed: true/false -> boolean, integers -> number, quoted -> string",
+							"\"body\" key is reserved for the markdown content below the frontmatter"
+						]
+					},
+					dictionary: {
+						description: "Flat key-value string map (e.g. i18n translation files)",
+						storage_format: "JSON object: { \"greeting\": \"Hello\", \"farewell\": \"Goodbye\" }",
+						note: "All values must be strings."
+					}
+				},
+				meta_files: {
+					description: "Metadata is stored separately from content in .contentrain/meta/{model-id}/",
+					collection_meta: "Object-map: { \"entry-id\": { \"status\": \"draft\", \"source\": \"agent\", \"updated_by\": \"contentrain-mcp\" } }",
+					singleton_meta: "Single object: { \"status\": \"published\", \"source\": \"human\", \"updated_by\": \"user@example.com\" }",
+					fields: {
+						status: "Content lifecycle status: \"draft\" | \"in_review\" | \"published\" | \"rejected\" | \"archived\"",
+						source: "Who created the entry: \"agent\" | \"human\" | \"import\"",
+						updated_by: "Author identifier string",
+						approved_by: "Optional: approver identifier",
+						version: "Optional: version string",
+						publish_at: "Optional: ISO 8601 date for scheduled publishing",
+						expire_at: "Optional: ISO 8601 date for scheduled expiry (must be after publish_at)"
+					}
+				},
+				locale_strategies: {
+					description: "How localized content files are organized. Set per-model via locale_strategy field.",
+					strategies: {
+						file: {
+							description: "Default. Each locale is a separate file in the model directory.",
+							json_pattern: "{content-dir}/{locale}.json (e.g. en.json, tr.json)",
+							md_pattern: "{content-dir}/{slug}/{locale}.md"
+						},
+						suffix: {
+							description: "Locale appended to filename.",
+							json_pattern: "{content-dir}/{model-id}.{locale}.json",
+							md_pattern: "{content-dir}/{slug}.{locale}.md"
+						},
+						directory: {
+							description: "Locale as subdirectory.",
+							json_pattern: "{content-dir}/{locale}/{model-id}.json",
+							md_pattern: "{content-dir}/{locale}/{slug}.md"
+						},
+						none: {
+							description: "No locale in path (single-language or externally managed).",
+							json_pattern: "{content-dir}/{model-id}.json",
+							md_pattern: "{content-dir}/{slug}.md"
+						}
+					}
+				},
+				i18n_disabled: {
+					description: "When a model has i18n:false, locale is ignored in file paths.",
+					json_pattern: "{content-dir}/data.json (always \"data.json\", no locale suffix)",
+					md_pattern: "{content-dir}/{slug}.md (no locale in path)"
+				},
+				canonical_serialization: {
+					description: "All JSON files use deterministic serialization for clean git diffs.",
+					rules: [
+						"Object keys sorted alphabetically",
+						"2-space indentation",
+						"Trailing newline at end of file",
+						"No trailing commas",
+						"UTF-8 encoding"
+					]
+				},
+				content_path_override: {
+					description: "Models can specify a custom content_path to store content outside .contentrain/content/.",
+					example: "A model with content_path: \"content/blog\" stores files at {project-root}/content/blog/ instead of .contentrain/content/{domain}/{model-id}/",
+					note: "This is useful for frameworks that expect content in specific directories (e.g. Nuxt Content, Astro)."
+				},
+				reading_content: { steps: [
+					"1. Read .contentrain/config.json to get locales and workflow settings",
+					"2. Read .contentrain/models/{model-id}.json to get the schema and model kind",
+					"3. Determine content directory: model.content_path or .contentrain/content/{domain}/{model-id}/",
+					"4. Determine file path using locale_strategy and i18n flag",
+					"5. Parse JSON (collection/singleton/dictionary) or Markdown frontmatter (document)",
+					"6. Optionally read .contentrain/meta/{model-id}/{locale}.json for status/metadata"
+				] }
+			}, null, 2)
+		}] };
+	});
+}
+async function getSample(projectRoot, model, locale) {
+	const { readJson, readDir } = await import("./util/fs.mjs");
+	const cDir = resolveContentDir(projectRoot, model);
+	if (model.kind === "collection") {
+		const data = await readJson(resolveJsonFilePath(cDir, model, locale));
+		if (!data) return null;
+		const firstKey = Object.keys(data)[0];
+		return firstKey ? {
+			id: firstKey,
+			...data[firstKey]
+		} : null;
+	}
+	if (model.kind === "singleton" || model.kind === "dictionary") return readJson(resolveJsonFilePath(cDir, model, locale));
+	if (model.kind === "document") {
+		const strategy = resolveLocaleStrategy(model);
+		if (!model.i18n) {
+			const slug = (await readDir(cDir)).find((item) => item.endsWith(".md"))?.replace(/\.md$/u, "");
+			return slug ? {
+				slug,
+				locale
+			} : null;
+		}
+		if (strategy === "file") {
+			const slug = (await readDir(cDir))[0];
+			return slug ? {
+				slug,
+				locale
+			} : null;
+		}
+		if (strategy === "suffix") {
+			const suffix = `.${locale}.md`;
+			const slug = (await readDir(cDir)).find((file) => file.endsWith(suffix))?.slice(0, -suffix.length);
+			return slug ? {
+				slug,
+				locale
+			} : null;
+		}
+		if (strategy === "directory") {
+			const slug = (await readDir(join(cDir, locale))).find((item) => item.endsWith(".md"))?.replace(/\.md$/u, "");
+			return slug ? {
+				slug,
+				locale
+			} : null;
+		}
+		const slug = (await readDir(cDir)).find((item) => item.endsWith(".md"))?.replace(/\.md$/u, "");
+		return slug ? {
+			slug,
+			locale
+		} : null;
+	}
+	return null;
+}
+function buildContentPath(model, locale) {
+	const strategy = model.locale_strategy ?? "file";
+	const baseDir = model.content_path ?? `.contentrain/content/${model.domain}/${model.id}`;
+	if (model.kind === "document") {
+		if (!model.i18n) return `${baseDir}/{slug}.md`;
+		switch (strategy) {
+			case "suffix": return `${baseDir}/{slug}.${locale}.md`;
+			case "directory": return `${baseDir}/${locale}/{slug}.md`;
+			case "none": return `${baseDir}/{slug}.md`;
+			default: return `${baseDir}/{slug}/${locale}.md`;
+		}
+	}
+	if (!model.i18n) return `${baseDir}/data.json`;
+	switch (strategy) {
+		case "suffix": return `${baseDir}/${model.id}.${locale}.json`;
+		case "directory": return `${baseDir}/${locale}/${model.id}.json`;
+		case "none": return `${baseDir}/${model.id}.json`;
+		default: return `${baseDir}/${locale}.json`;
+	}
+}
+function generateImportSnippet(model, stack, locale) {
+	const path = buildContentPath(model, locale);
+	const snippets = { generic: `import data from '${path}'` };
+	switch (stack) {
+		case "nuxt":
+			snippets["nuxt"] = model.kind === "document" ? `const { data } = await useAsyncData(() => queryContent('${model.domain}/${model.id}').locale('${locale}').find())` : `const { data } = await useFetch('/api/content/${model.id}?locale=${locale}')`;
+			break;
+		case "next":
+			snippets["next"] = `import data from '@/${path}'`;
+			break;
+		case "astro":
+			snippets["astro"] = `import data from '~/${path}'`;
+			break;
+	}
+	return snippets;
+}
+//#endregion
+//#region src/tools/setup.ts
+function registerSetupTools(server, projectRoot) {
+	server.tool("contentrain_init", "Initialize .contentrain/ structure. Changes are auto-committed to git — do NOT manually create .contentrain/ files.", {
+		stack: z.string().optional().describe("Framework stack (nuxt, next, astro, svelte, react-vite, other). Auto-detected if omitted."),
+		locales: z.array(z.string()).optional().describe("Supported locales. Default: [\"en\"]"),
+		domains: z.array(z.string()).optional().describe("Content domains. Default: auto-suggested")
+	}, async ({ stack, locales, domains }) => {
+		if (await pathExists(join(contentrainDir(projectRoot), "config.json"))) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({
+					error: "Already initialized",
+					suggestion: "Use contentrain_status to see current state"
+				})
+			}],
+			isError: true
+		};
+		const detectedStack = stack ?? await detectStack(projectRoot);
+		const supportedLocales = locales ?? ["en"];
+		const suggestedDomains = domains ?? suggestDomains(projectRoot);
+		if (!await pathExists(join(projectRoot, ".git"))) await simpleGit(projectRoot).init();
+		const initHealth = await checkBranchHealth(projectRoot);
+		if (initHealth.blocked) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({
+					error: initHealth.message,
+					action: "blocked",
+					hint: "Merge or delete old contentrain/* branches before creating new ones."
+				}, null, 2)
+			}],
+			isError: true
+		};
+		const branch = buildBranchName("new", "init");
+		const tx = await createTransaction(projectRoot, branch);
+		try {
+			await tx.write(async (wt) => {
+				const wtCrDir = join(wt, ".contentrain");
+				await Promise.all([
+					"models",
+					"content",
+					"meta"
+				].map(async (dir) => {
+					await ensureDir(join(wtCrDir, dir));
+					await writeFile(join(wtCrDir, dir, ".gitkeep"), "", "utf-8");
+				}));
+				const config = {
+					version: 1,
+					stack: detectedStack,
+					workflow: "auto-merge",
+					locales: {
+						default: supportedLocales[0] ?? "en",
+						supported: supportedLocales
+					},
+					domains: suggestedDomains
+				};
+				await writeJson(join(wtCrDir, "config.json"), config);
+				await writeJson(join(wtCrDir, "vocabulary.json"), {
+					version: 1,
+					terms: {}
+				});
+				await writeJson(join(wtCrDir, "context.json"), {
+					version: "1",
+					lastOperation: {
+						tool: "contentrain_init",
+						model: "",
+						locale: supportedLocales[0] ?? "en",
+						timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+						source: process.env["CONTENTRAIN_SOURCE"] === "mcp-studio" ? "mcp-studio" : "mcp-local"
+					},
+					stats: {
+						models: 0,
+						entries: 0,
+						locales: supportedLocales,
+						lastSync: (/* @__PURE__ */ new Date()).toISOString()
+					}
+				});
+				await updateGitignore(wt);
+			});
+			await tx.commit("[contentrain] init: project setup");
+			const gitResult = await tx.complete({
+				tool: "contentrain_init",
+				model: "",
+				locale: supportedLocales[0] ?? "en"
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: "committed",
+					message: "Project initialized and committed to git. Do NOT manually edit .contentrain/ files.",
+					config_created: ".contentrain/config.json",
+					detected_stack: detectedStack,
+					detected_locales: supportedLocales,
+					suggested_domains: suggestedDomains,
+					files_created: [
+						".contentrain/config.json",
+						".contentrain/vocabulary.json",
+						".contentrain/context.json"
+					],
+					directories_created: [
+						".contentrain/models/",
+						".contentrain/content/",
+						".contentrain/meta/"
+					],
+					gitignore_updated: true,
+					git: {
+						branch,
+						action: gitResult.action,
+						commit: gitResult.commit
+					},
+					next_steps: ["Create models with contentrain_model_save or contentrain_scaffold", "Use contentrain_scan to find hardcoded strings"]
+				}, null, 2)
+			}] };
+		} catch (error) {
+			await tx.cleanup();
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: `Init failed: ${error instanceof Error ? error.message : String(error)}` })
+				}],
+				isError: true
+			};
+		} finally {
+			await tx.cleanup();
+		}
+	});
+	server.tool("contentrain_scaffold", `Template-based project setup. Available templates: ${listTemplates().join(", ")}. Changes are auto-committed to git.`, {
+		template: z.string().describe("Template ID: blog, landing, docs, ecommerce, saas, i18n, mobile"),
+		locales: z.array(z.string()).optional().describe("Override locales"),
+		with_sample_content: z.boolean().optional().default(true).describe("Include sample content (default: true)")
+	}, async ({ template: templateId, locales, with_sample_content }) => {
+		const config = await readConfig(projectRoot);
+		if (!config) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: "Project not initialized. Run contentrain_init first." })
+			}],
+			isError: true
+		};
+		const tmpl = getTemplate(templateId);
+		if (!tmpl) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: `Unknown template: "${templateId}". Available: ${listTemplates().join(", ")}` })
+			}],
+			isError: true
+		};
+		const scaffoldHealth = await checkBranchHealth(projectRoot);
+		if (scaffoldHealth.blocked) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({
+					error: scaffoldHealth.message,
+					action: "blocked",
+					hint: "Merge or delete old contentrain/* branches before creating new ones."
+				}, null, 2)
+			}],
+			isError: true
+		};
+		const effectiveLocales = locales ?? config.locales.supported;
+		const defaultLocale = effectiveLocales[0] ?? "en";
+		const branch = buildBranchName("new", `scaffold-${templateId}`, defaultLocale);
+		const tx = await createTransaction(projectRoot, branch);
+		try {
+			const modelsCreated = [];
+			let contentCreated = 0;
+			let vocabAdded = 0;
+			await tx.write(async (wt) => {
+				await Promise.all(tmpl.models.map(async (model) => {
+					await writeModel(wt, model);
+					modelsCreated.push({
+						id: model.id,
+						kind: model.kind,
+						fields: model.fields ? Object.keys(model.fields).length : 0
+					});
+				}));
+				if (with_sample_content && tmpl.sample_content) contentCreated = await writeSampleContent(wt, tmpl, effectiveLocales, config);
+				if (tmpl.vocabulary) vocabAdded = await mergeVocabulary(wt, tmpl.vocabulary, effectiveLocales);
+			});
+			await tx.commit(`[contentrain] scaffold: ${templateId} (${defaultLocale})`);
+			const gitResult = await tx.complete({
+				tool: "contentrain_scaffold",
+				model: tmpl.models.map((m) => m.id).join(", "),
+				locale: defaultLocale
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: "committed",
+					message: "Scaffold applied and committed to git. Do NOT manually edit .contentrain/ files.",
+					models_created: modelsCreated,
+					content_created: contentCreated,
+					vocabulary_terms_added: vocabAdded,
+					git: {
+						branch,
+						action: gitResult.action,
+						commit: gitResult.commit
+					},
+					context_updated: true,
+					next_steps: [
+						"Customize models with contentrain_model_save",
+						"Add content with contentrain_content_save",
+						"Run contentrain_submit when ready"
+					]
+				}, null, 2)
+			}] };
+		} catch (error) {
+			await tx.cleanup();
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: `Scaffold failed: ${error instanceof Error ? error.message : String(error)}` })
+				}],
+				isError: true
+			};
+		} finally {
+			await tx.cleanup();
+		}
+	});
+}
+function suggestDomains(_projectRoot) {
+	return [
+		"marketing",
+		"blog",
+		"system"
+	];
+}
+async function updateGitignore(projectRoot) {
+	const gitignorePath = join(projectRoot, ".gitignore");
+	const cacheEntry = ".contentrain/.cache/";
+	if (await pathExists(gitignorePath)) {
+		if (!(await readFile(gitignorePath, "utf-8")).includes(cacheEntry)) await appendFile(gitignorePath, `\n# Contentrain cache\n${cacheEntry}\n`);
+	} else await writeFile(gitignorePath, `# Contentrain cache\n${cacheEntry}\n`, "utf-8");
+}
+async function writeSampleContent(worktreePath, tmpl, locales, config) {
+	if (!tmpl.sample_content) return 0;
+	let count = 0;
+	for (const model of tmpl.models) {
+		const sampleData = tmpl.sample_content[model.id];
+		if (!sampleData) continue;
+		for (const [localeOrKey, data] of Object.entries(sampleData)) {
+			const entryMap = data;
+			let targetLocale;
+			if (localeOrKey === "data") targetLocale = locales[0] ?? "en";
+			else if (locales.includes(localeOrKey)) targetLocale = localeOrKey;
+			else continue;
+			let entries;
+			if (model.kind === "singleton" || model.kind === "dictionary") entries = [{
+				locale: targetLocale,
+				data: entryMap
+			}];
+			else if (model.kind === "document") entries = Object.entries(entryMap).map(([slug, fields]) => ({
+				slug,
+				locale: targetLocale,
+				data: fields
+			}));
+			else entries = Object.entries(entryMap).map(([id, fields]) => ({
+				id,
+				locale: targetLocale,
+				data: fields
+			}));
+			await writeContent(worktreePath, model, entries, config);
+			count += entries.length;
+		}
+	}
+	return count;
+}
+async function mergeVocabulary(projectRoot, newTerms, _locales) {
+	const vocabPath = join(contentrainDir(projectRoot), "vocabulary.json");
+	const vocab = await readVocabulary(projectRoot) ?? {
+		version: 1,
+		terms: {}
+	};
+	let added = 0;
+	for (const [key, translations] of Object.entries(newTerms)) {
+		if (!(key in vocab.terms)) added++;
+		vocab.terms[key] = {
+			...vocab.terms[key],
+			...translations
+		};
+	}
+	await writeJson(vocabPath, vocab);
+	return added;
+}
+//#endregion
+//#region src/tools/model.ts
+const fieldDefSchema = fieldDefZodSchema;
+function registerModelTools(server, projectRoot) {
+	server.tool("contentrain_model_save", "Create or update a model definition. Changes are auto-committed to git — do NOT manually edit .contentrain/ files after calling this tool.", {
+		id: z.string().describe("Model ID (kebab-case, e.g. \"blog-post\")"),
+		name: z.string().describe("Human-readable name"),
+		kind: z.enum([
+			"singleton",
+			"collection",
+			"document",
+			"dictionary"
+		]).describe("Model kind"),
+		domain: z.string().describe("Content domain (e.g. \"blog\", \"marketing\", \"system\")"),
+		i18n: z.boolean().describe("Whether this model supports localization"),
+		description: z.string().optional().describe("Model description"),
+		fields: fieldDefSchema.optional().describe("Field definitions (not needed for dictionary)"),
+		content_path: z.string().optional().describe("Framework-relative path for content files (e.g. \"content/blog\", \"locales\"). When set, content is written here instead of .contentrain/content/"),
+		locale_strategy: z.enum([
+			"file",
+			"suffix",
+			"directory",
+			"none"
+		]).optional().describe("How locale is encoded in file names. Default: \"file\"")
+	}, async (input) => {
+		const config = await readConfig(projectRoot);
+		if (!config) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: "Project not initialized. Run contentrain_init first." })
+			}],
+			isError: true
+		};
+		const errors = validateModel(input);
+		if (errors.length > 0) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({
+					error: "Validation failed",
+					details: errors
+				})
+			}],
+			isError: true
+		};
+		if (input.locale_strategy === "none" && input.i18n !== false) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: "locale_strategy \"none\" requires i18n:false. The \"none\" strategy stores a single file without locale encoding, which is incompatible with multi-locale content. Use \"file\", \"suffix\", or \"directory\" for i18n models." })
+			}],
+			isError: true
+		};
+		const health = await checkBranchHealth(projectRoot);
+		if (health.blocked) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({
+					error: health.message,
+					action: "blocked",
+					hint: "Merge or delete old contentrain/* branches before creating new ones."
+				}, null, 2)
+			}],
+			isError: true
+		};
+		const action = await readModel(projectRoot, input.id) ? "updated" : "created";
+		const model = {
+			id: input.id,
+			name: input.name,
+			kind: input.kind,
+			domain: input.domain,
+			i18n: input.i18n,
+			description: input.description,
+			fields: input.fields,
+			content_path: input.content_path,
+			locale_strategy: input.locale_strategy
+		};
+		const branch = buildBranchName("model", input.id);
+		const tx = await createTransaction(projectRoot, branch);
+		try {
+			await tx.write(async (wt) => {
+				await writeModel(wt, model);
+			});
+			await tx.commit(`[contentrain] ${action}: ${input.id}`);
+			const gitResult = await tx.complete({
+				tool: "contentrain_model_save",
+				model: input.id
+			});
+			const defaultLocale = config.locales.default;
+			const contentDir = resolveContentDir(projectRoot, model);
+			const contentPath = model.content_path ?? `.contentrain/content/${input.domain}/${input.id}`;
+			let exampleFilePath;
+			if (model.kind === "document") exampleFilePath = resolveMdFilePath(contentDir, model, defaultLocale, "{slug}");
+			else exampleFilePath = resolveJsonFilePath(contentDir, model, defaultLocale);
+			const displayPath = exampleFilePath.replace(projectRoot + "/", "").replace(projectRoot, "");
+			const importSnippet = { generic: `import data from '${displayPath}'` };
+			if (config.stack === "nuxt") importSnippet["nuxt"] = model.kind === "document" ? `const { data } = await useAsyncData(() => queryContent('${model.domain}/${model.id}').locale('${defaultLocale}').find())` : `const { data } = await useFetch('/api/content/${model.id}?locale=${defaultLocale}')`;
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: "committed",
+					message: "Model saved and committed to git. Do NOT manually edit .contentrain/ files.",
+					action,
+					model: input.id,
+					validation: {
+						valid: true,
+						errors: []
+					},
+					git: {
+						branch,
+						action: gitResult.action,
+						commit: gitResult.commit
+					},
+					context_updated: true,
+					content_path: contentPath + "/",
+					example_file: displayPath,
+					import_snippet: importSnippet,
+					next_steps: ["Add content with contentrain_content_save"]
+				}, null, 2)
+			}] };
+		} catch (error) {
+			await tx.cleanup();
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: `Model save failed: ${error instanceof Error ? error.message : String(error)}` })
+				}],
+				isError: true
+			};
+		} finally {
+			await tx.cleanup();
+		}
+	});
+	server.tool("contentrain_model_delete", "Delete a model and its content/meta. Changes are auto-committed to git — do NOT manually edit .contentrain/ files.", {
+		model: z.string().describe("Model ID to delete"),
+		confirm: z.literal(true).describe("Must be true to confirm deletion")
+	}, async ({ model: modelId }) => {
+		if (!await readConfig(projectRoot)) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: "Project not initialized." })
+			}],
+			isError: true
+		};
+		if (!await readModel(projectRoot, modelId)) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: `Model "${modelId}" not found` })
+			}],
+			isError: true
+		};
+		const deleteHealth = await checkBranchHealth(projectRoot);
+		if (deleteHealth.blocked) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({
+					error: deleteHealth.message,
+					action: "blocked",
+					hint: "Merge or delete old contentrain/* branches before creating new ones."
+				}, null, 2)
+			}],
+			isError: true
+		};
+		const refs = await checkReferences(projectRoot, modelId);
+		if (refs.length > 0) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				deleted: false,
+				error: "REFERENCED_MODEL",
+				referenced_by: refs,
+				next_steps: ["Remove relation fields from referencing models first"]
+			}, null, 2)
+		}] };
+		const branch = buildBranchName("model", modelId);
+		const tx = await createTransaction(projectRoot, branch);
+		try {
+			let filesRemoved = [];
+			await tx.write(async (wt) => {
+				filesRemoved = await deleteModel(wt, modelId);
+			});
+			await tx.commit(`[contentrain] delete: ${modelId}`);
+			const gitResult = await tx.complete({
+				tool: "contentrain_model_delete",
+				model: modelId
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: "committed",
+					message: "Model deleted and committed to git. Do NOT manually edit .contentrain/ files.",
+					deleted: true,
+					git: {
+						branch,
+						action: gitResult.action,
+						commit: gitResult.commit
+					},
+					files_removed: filesRemoved,
+					context_updated: true
+				}, null, 2)
+			}] };
+		} catch (error) {
+			await tx.cleanup();
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: `Delete failed: ${error instanceof Error ? error.message : String(error)}` })
+				}],
+				isError: true
+			};
+		} finally {
+			await tx.cleanup();
+		}
+	});
+}
+const validateModel = validateModelDefinition;
+//#endregion
+//#region src/tools/content.ts
+function registerContentTools(server, projectRoot) {
+	server.tool("contentrain_content_save", "Save content entries. Entry format varies by model kind: DICTIONARY — provide \"locale\" and \"data\" (flat key-value, all string values); \"id\" and \"slug\" are ignored; data keys are the identities. COLLECTION — provide \"locale\" and \"data\"; \"id\" is optional (auto-generated if omitted); \"slug\" is ignored. DOCUMENT — provide \"slug\" (required), \"locale\", and \"data\"; use the \"body\" key inside data for markdown content. SINGLETON — provide only \"locale\" and \"data\". Changes are auto-committed to git — do NOT manually edit .contentrain/ files after calling this tool.", {
+		model: z.string().describe("Model ID"),
+		entries: z.array(z.object({
+			id: z.string().optional().describe("Entry ID (collection only, auto-generated if omitted)"),
+			slug: z.string().optional().describe("Slug (document only)"),
+			locale: z.string().optional().describe("Locale code (defaults to config default)"),
+			data: z.record(z.string(), z.unknown()).describe("Content data. For documents, include \"body\" key for markdown content."),
+			publish_at: z.string().optional().describe("ISO 8601 date for scheduled publishing (stored in meta)"),
+			expire_at: z.string().optional().describe("ISO 8601 date for scheduled expiry (stored in meta, must be after publish_at)")
+		})).describe("Content entries to save")
+	}, async (input) => {
+		const config = await readConfig(projectRoot);
+		if (!config) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: "Project not initialized. Run contentrain_init first." })
+			}],
+			isError: true
+		};
+		const model = await readModel(projectRoot, input.model);
+		if (!model) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: `Model "${input.model}" not found` })
+			}],
+			isError: true
+		};
+		for (const entry of input.entries) {
+			if (entry.locale && !config.locales.supported.includes(entry.locale)) return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: `Locale "${entry.locale}" is not supported. Supported: [${config.locales.supported.join(", ")}]` })
+				}],
+				isError: true
+			};
+			if (entry.publish_at !== void 0) {
+				const d = new Date(entry.publish_at);
+				if (Number.isNaN(d.getTime())) return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: `Invalid publish_at date: "${entry.publish_at}". Must be a valid ISO 8601 date string.` })
+					}],
+					isError: true
+				};
+			}
+			if (entry.expire_at !== void 0) {
+				const d = new Date(entry.expire_at);
+				if (Number.isNaN(d.getTime())) return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: `Invalid expire_at date: "${entry.expire_at}". Must be a valid ISO 8601 date string.` })
+					}],
+					isError: true
+				};
+			}
+			if (entry.publish_at !== void 0 && entry.expire_at !== void 0) {
+				if (new Date(entry.expire_at) <= new Date(entry.publish_at)) return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: `expire_at ("${entry.expire_at}") must be after publish_at ("${entry.publish_at}").` })
+					}],
+					isError: true
+				};
+			}
+			if (entry.publish_at !== void 0) entry.data["publish_at"] = entry.publish_at;
+			if (entry.expire_at !== void 0) entry.data["expire_at"] = entry.expire_at;
+		}
+		const health = await checkBranchHealth(projectRoot);
+		if (health.blocked) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({
+					error: health.message,
+					action: "blocked",
+					hint: "Merge or delete old contentrain/* branches before creating new ones."
+				}, null, 2)
+			}],
+			isError: true
+		};
+		const branch = buildBranchName("content", input.model);
+		const tx = await createTransaction(projectRoot, branch);
+		try {
+			let results;
+			let entryIds = [];
+			await tx.write(async (wt) => {
+				results = await writeContent(wt, model, input.entries, config);
+				entryIds = results.map((r) => r.id ?? r.slug ?? r.locale).filter(Boolean);
+			});
+			await tx.commit(`[contentrain] content: ${input.model}`);
+			const gitResult = await tx.complete({
+				tool: "contentrain_content_save",
+				model: input.model,
+				locale: input.entries[0]?.locale,
+				entries: entryIds
+			});
+			const validationResult = await validateProject(projectRoot, { model: input.model });
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: "committed",
+					message: "Content saved and committed to git. Do NOT manually edit .contentrain/ files.",
+					results,
+					git: {
+						branch,
+						action: gitResult.action,
+						commit: gitResult.commit
+					},
+					validation: {
+						valid: validationResult.valid,
+						errors: validationResult.issues.filter((i) => i.severity === "error").map((i) => i.message)
+					},
+					context_updated: true,
+					next_steps: [...!validationResult.valid ? ["WARNING: Content has validation errors — run contentrain_validate for details"] : [], ...model.kind === "collection" ? ["Use contentrain_content_list to verify", "Add more entries or publish"] : ["Use contentrain_content_list to verify"]]
+				}, null, 2)
+			}] };
+		} catch (error) {
+			await tx.cleanup();
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: `Content save failed: ${error instanceof Error ? error.message : String(error)}` })
+				}],
+				isError: true
+			};
+		} finally {
+			await tx.cleanup();
+		}
+	});
+	server.tool("contentrain_content_delete", "Delete content entries. For dictionaries, use \"keys\" to remove specific keys (omit to delete entire locale file). Changes are auto-committed to git — do NOT manually edit .contentrain/ files after calling this tool.", {
+		model: z.string().describe("Model ID"),
+		id: z.string().optional().describe("Entry ID (collection)"),
+		slug: z.string().optional().describe("Slug (document)"),
+		locale: z.string().optional().describe("Locale code"),
+		keys: z.array(z.string()).optional().describe("Dictionary only: specific keys to remove. Omit to delete entire locale file."),
+		confirm: z.literal(true).describe("Must be true to confirm deletion")
+	}, async (input) => {
+		if (!await readConfig(projectRoot)) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: "Project not initialized." })
+			}],
+			isError: true
+		};
+		const model = await readModel(projectRoot, input.model);
+		if (!model) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: `Model "${input.model}" not found` })
+			}],
+			isError: true
+		};
+		const deleteHealth = await checkBranchHealth(projectRoot);
+		if (deleteHealth.blocked) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({
+					error: deleteHealth.message,
+					action: "blocked",
+					hint: "Merge or delete old contentrain/* branches before creating new ones."
+				}, null, 2)
+			}],
+			isError: true
+		};
+		const branch = buildBranchName("content", input.model);
+		const tx = await createTransaction(projectRoot, branch);
+		try {
+			let removed = [];
+			await tx.write(async (wt) => {
+				removed = await deleteContent(wt, model, {
+					id: input.id,
+					slug: input.slug,
+					locale: input.locale,
+					keys: input.keys
+				});
+			});
+			await tx.commit(`[contentrain] delete content: ${input.model}`);
+			const gitResult = await tx.complete({
+				tool: "contentrain_content_delete",
+				model: input.model,
+				locale: input.locale
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: "committed",
+					message: "Content deleted and committed to git. Do NOT manually edit .contentrain/ files.",
+					deleted: true,
+					files_removed: removed,
+					git: {
+						branch,
+						action: gitResult.action,
+						commit: gitResult.commit
+					},
+					context_updated: true
+				}, null, 2)
+			}] };
+		} catch (error) {
+			await tx.cleanup();
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: `Delete failed: ${error instanceof Error ? error.message : String(error)}` })
+				}],
+				isError: true
+			};
+		} finally {
+			await tx.cleanup();
+		}
+	});
+	server.tool("contentrain_content_list", "List content entries (read-only). Returns data from .contentrain/ — do NOT manually create or modify content files.", {
+		model: z.string().describe("Model ID"),
+		locale: z.string().optional().describe("Locale code (defaults to config default)"),
+		filter: z.record(z.string(), z.unknown()).optional().describe("Filter criteria (collection only)"),
+		resolve: z.boolean().optional().describe("Resolve relation fields to actual data"),
+		limit: z.number().optional().describe("Max entries to return"),
+		offset: z.number().optional().describe("Skip N entries")
+	}, async (input) => {
+		const config = await readConfig(projectRoot);
+		if (!config) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: "Project not initialized." })
+			}],
+			isError: true
+		};
+		const model = await readModel(projectRoot, input.model);
+		if (!model) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: `Model "${input.model}" not found` })
+			}],
+			isError: true
+		};
+		try {
+			const result = await listContent(projectRoot, model, {
+				locale: input.locale,
+				filter: input.filter,
+				resolve: input.resolve,
+				limit: input.limit,
+				offset: input.offset
+			}, config);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: `List failed: ${error instanceof Error ? error.message : String(error)}` })
+				}],
+				isError: true
+			};
+		}
+	});
+}
+//#endregion
+//#region src/tools/workflow.ts
+function registerWorkflowTools(server, projectRoot) {
+	server.tool("contentrain_validate", "Validate project content against model schemas. Detects required field violations, type mismatches, broken relations, secret leaks, i18n parity issues, and more. If fix:true, auto-fixes structural issues (canonical sort, orphan meta, missing locale files) — do NOT manually edit .contentrain/ files.", {
+		model: z.string().optional().describe("Model ID to validate (omit for all models)"),
+		fix: z.boolean().optional().describe("Auto-fix structural issues (canonical sort, orphan meta, missing locale files). Default: false")
+	}, async (input) => {
+		if (!await readConfig(projectRoot)) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: "Project not initialized. Run contentrain_init first." })
+			}],
+			isError: true
+		};
+		try {
+			let result;
+			if (input.fix) {
+				const fixHealth = await checkBranchHealth(projectRoot);
+				if (fixHealth.blocked) return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({
+							error: fixHealth.message,
+							action: "blocked",
+							hint: "Merge or delete old contentrain/* branches before auto-fixing."
+						}, null, 2)
+					}],
+					isError: true
+				};
+				const branch = buildBranchName("fix", "validate");
+				const tx = await createTransaction(projectRoot, branch);
+				try {
+					await tx.write(async (wt) => {
+						result = await validateProject(wt, {
+							model: input.model,
+							fix: true
+						});
+					});
+					if (result.fixed > 0) {
+						await tx.commit(`[contentrain] validate: auto-fix ${result.fixed} issue(s)`);
+						const gitResult = await tx.complete({
+							tool: "contentrain_validate",
+							model: input.model ?? "*"
+						});
+						const nextSteps = [];
+						if (result.summary.errors > 0) nextSteps.push("Fix remaining errors manually");
+						if (result.summary.warnings > 0) nextSteps.push("Review warnings");
+						nextSteps.push("Run contentrain_validate again to verify");
+						return { content: [{
+							type: "text",
+							text: JSON.stringify({
+								status: "committed",
+								message: `Validation complete. ${result.fixed} issue(s) auto-fixed and committed to git. Do NOT manually edit .contentrain/ files.`,
+								...result,
+								git: {
+									branch,
+									action: gitResult.action,
+									commit: gitResult.commit
+								},
+								context_updated: true,
+								next_steps: nextSteps
+							}, null, 2)
+						}] };
+					} else await tx.cleanup();
+				} catch (error) {
+					await tx.cleanup();
+					throw error;
+				} finally {
+					await tx.cleanup();
+				}
+			}
+			if (!result) result = await validateProject(projectRoot, {
+				model: input.model,
+				fix: false
+			});
+			const nextSteps = [];
+			if (result.summary.errors > 0) nextSteps.push("Fix errors in content using contentrain_content_save");
+			if (result.summary.warnings > 0) nextSteps.push("Review warnings");
+			if (result.valid) nextSteps.push("Run contentrain_submit to push changes");
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: "validated",
+					message: result.valid ? "All validation checks passed." : `Validation found ${result.summary.errors} error(s) and ${result.summary.warnings} warning(s).`,
+					...result,
+					next_steps: nextSteps
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: `Validation failed: ${error instanceof Error ? error.message : String(error)}` })
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("contentrain_submit", "Push contentrain/* branches to remote. MCP is push-only — PR creation is handled by the platform. Do NOT manually push or create PRs.", {
+		branches: z.array(z.string()).optional().describe("Specific branch names to push (omit for all contentrain/* branches)"),
+		message: z.string().optional().describe("Optional message for the push operation")
+	}, async (input) => {
+		const config = await readConfig(projectRoot);
+		if (!config) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: "Project not initialized. Run contentrain_init first." })
+			}],
+			isError: true
+		};
+		const git = simpleGit(projectRoot);
+		const remoteName = process.env["CONTENTRAIN_REMOTE"] ?? "origin";
+		let hasRemote = false;
+		try {
+			hasRemote = (await git.getRemotes()).some((r) => r.name === remoteName);
+		} catch {
+			hasRemote = false;
+		}
+		if (!hasRemote) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({
+					error: `No remote "${remoteName}" found. Configure a git remote first.`,
+					next_steps: [`git remote add ${remoteName} <url>`]
+				})
+			}],
+			isError: true
+		};
+		try {
+			const baseBranch = config.repository?.default_branch ?? process.env["CONTENTRAIN_BRANCH"] ?? ((await git.raw(["branch", "--show-current"])).trim() || "main");
+			const branchSummary = await git.branchLocal();
+			let unmergedRaw = "";
+			try {
+				unmergedRaw = await git.raw([
+					"branch",
+					"--no-merged",
+					baseBranch
+				]);
+			} catch {
+				unmergedRaw = branchSummary.all.join("\n");
+			}
+			const unmergedSet = new Set(unmergedRaw.split("\n").map((b) => b.replace(/^\*?\s+/, "").trim()).filter(Boolean));
+			let branchesToPush;
+			if (input.branches && input.branches.length > 0) {
+				branchesToPush = input.branches.filter((b) => branchSummary.all.includes(b));
+				const missing = input.branches.filter((b) => !branchSummary.all.includes(b));
+				if (missing.length > 0) return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: `Branches not found: ${missing.join(", ")}` })
+					}],
+					isError: true
+				};
+				branchesToPush = branchesToPush.filter((b) => unmergedSet.has(b));
+			} else branchesToPush = branchSummary.all.filter((b) => b.startsWith("contentrain/") && unmergedSet.has(b));
+			if (branchesToPush.length === 0) return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						error: "No unmerged contentrain/* branches found to push.",
+						next_steps: ["Make changes first with contentrain_content_save or contentrain_model_save"]
+					})
+				}],
+				isError: true
+			};
+			const pushed = [];
+			const errors = [];
+			for (const branch of branchesToPush) try {
+				await git.push(remoteName, branch);
+				pushed.push(branch);
+			} catch (error) {
+				errors.push({
+					branch,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			}
+			const cleanup = await cleanupMergedBranches(projectRoot);
+			const nextSteps = [];
+			if (pushed.length > 0) nextSteps.push("Create PRs on your git platform for review");
+			if (errors.length > 0) nextSteps.push("Fix push errors and retry");
+			if (cleanup.remaining >= 50) nextSteps.push(`Warning: ${cleanup.remaining} active contentrain branches. Consider reviewing old branches.`);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: "committed",
+					message: `Pushed ${pushed.length} branch(es) to ${remoteName}.`,
+					pushed,
+					errors: errors.length > 0 ? errors : void 0,
+					remote: remoteName,
+					cleanup: cleanup.deleted > 0 ? {
+						deleted: cleanup.deleted,
+						remaining: cleanup.remaining
+					} : void 0,
+					next_steps: nextSteps
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: `Submit failed: ${error instanceof Error ? error.message : String(error)}` })
+				}],
+				isError: true
+			};
+		}
+	});
+}
+//#endregion
+//#region src/tools/normalize.ts
+function registerNormalizeTools(server, projectRoot) {
+	server.tool("contentrain_scan", "Scan project source code for content strings. Three modes: \"graph\" builds import/component graph for project intelligence, \"candidates\" extracts string literals with pre-filtering and pagination, \"summary\" provides quick overview stats. Read-only — no changes to disk or git. MCP finds strings deterministically; the agent decides what is content. Recommended workflow: start with \"summary\" or \"graph\" for orientation, then paginate through \"candidates\" to evaluate strings.", {
+		mode: z.enum([
+			"graph",
+			"candidates",
+			"summary"
+		]).optional().describe("Scan mode. Default: candidates"),
+		paths: z.array(z.string()).optional().describe("Directories to scan (relative to project root). Default: auto-detect"),
+		include: z.array(z.string()).optional().describe("File extensions to include. Default: .tsx, .jsx, .vue, .ts, .js, .mjs, .astro, .svelte"),
+		exclude: z.array(z.string()).optional().describe("Additional directory names to exclude"),
+		limit: z.number().optional().describe("Candidates mode: batch size. Default: 50"),
+		offset: z.number().optional().describe("Candidates mode: pagination offset. Default: 0"),
+		min_length: z.number().optional().describe("Candidates mode: minimum string length. Default: 2"),
+		max_length: z.number().optional().describe("Candidates mode: maximum string length. Default: 500")
+	}, async (input) => {
+		if (!await readConfig(projectRoot)) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: "Project not initialized. Run contentrain_init first." })
+			}],
+			isError: true
+		};
+		const mode = input.mode ?? "candidates";
+		try {
+			switch (mode) {
+				case "graph": {
+					const graph = await buildGraph(projectRoot, {
+						paths: input.paths,
+						include: input.include,
+						exclude: input.exclude
+					});
+					return { content: [{
+						type: "text",
+						text: JSON.stringify({
+							mode: "graph",
+							...graph,
+							next_steps: ["Use mode:candidates to scan specific files/directories for strings", "Focus on pages and components with high string counts first"]
+						}, null, 2)
+					}] };
+				}
+				case "candidates": {
+					const result = await scanCandidates(projectRoot, {
+						paths: input.paths,
+						include: input.include,
+						exclude: input.exclude,
+						limit: input.limit,
+						offset: input.offset,
+						min_length: input.min_length,
+						max_length: input.max_length
+					});
+					const nextSteps = [];
+					if (result.stats.has_more) nextSteps.push(`Use offset:${(input.offset ?? 0) + (input.limit ?? 50)} for next batch`);
+					nextSteps.push("Evaluate each candidate: is it user-facing content? Which domain/model?");
+					if (result.duplicates.length > 0) nextSteps.push("Consider deduplicating repeated strings into shared models");
+					return { content: [{
+						type: "text",
+						text: JSON.stringify({
+							mode: "candidates",
+							...result,
+							next_steps: nextSteps
+						}, null, 2)
+					}] };
+				}
+				case "summary": {
+					const result = await scanSummary(projectRoot, {
+						paths: input.paths,
+						include: input.include,
+						exclude: input.exclude,
+						min_length: input.min_length,
+						max_length: input.max_length
+					});
+					return { content: [{
+						type: "text",
+						text: JSON.stringify({
+							mode: "summary",
+							...result,
+							next_steps: ["Use mode:graph for project structure analysis", "Use mode:candidates to scan directories with most candidates"]
+						}, null, 2)
+					}] };
+				}
+				default: return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: `Unknown mode: ${mode}` })
+					}],
+					isError: true
+				};
+			}
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: `Scan failed: ${error instanceof Error ? error.message : String(error)}` })
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("contentrain_apply", "Apply normalize operations. Two modes: \"extract\" writes agent-approved strings to Contentrain content files (source untouched), \"reuse\" patches source files with agent-provided replacement expressions. DRY RUN (default, dry_run:true): validates inputs, resolves conflicts, and returns a full preview — NO changes to disk or git. EXECUTE (dry_run:false): writes files to disk, commits to a branch, and requires branch health check to pass. Recommended workflow: always run dry_run first, review the preview, then call again with dry_run:false to execute. Normalize operations always use review workflow (never auto-merge).", {
+		mode: z.enum(["extract", "reuse"]).describe("Apply mode: extract (content creation) or reuse (source patching)"),
+		dry_run: z.boolean().optional().default(true).describe("Defaults to preview mode (dry_run:true). Set dry_run:false to execute after reviewing the preview."),
+		extractions: z.array(z.object({
+			model: z.string().describe("Model ID (e.g. \"ui-texts\", \"hero-section\")"),
+			kind: z.enum([
+				"singleton",
+				"collection",
+				"dictionary",
+				"document"
+			]).describe("Model kind"),
+			domain: z.string().describe("Content domain (e.g. \"marketing\", \"app\")"),
+			i18n: z.boolean().optional().describe("Enable i18n. Default: true"),
+			fields: fieldDefZodSchema.optional().describe("Field definitions — shared schema with model_save for full parity"),
+			entries: z.array(z.object({
+				locale: z.string().optional().describe("Locale. Default: project default"),
+				slug: z.string().optional().describe("Document slug"),
+				data: z.record(z.any()).describe("Content data"),
+				source: z.object({
+					file: z.string().describe("Source file path"),
+					line: z.number().describe("Source line number"),
+					value: z.string().describe("Original string value")
+				}).optional().describe("Source tracking for traceability"),
+				sources: z.array(z.object({
+					file: z.string().describe("Source file path"),
+					line: z.number().describe("Source line number"),
+					key: z.string().describe("Dictionary key this source maps to"),
+					value: z.string().describe("Original string value")
+				})).optional().describe("Per-key source tracking for dictionary models")
+			})).describe("Content entries to create")
+		})).optional().describe("Extract mode: content extractions"),
+		scope: z.object({
+			model: z.string().optional().describe("Target model ID"),
+			domain: z.string().optional().describe("Target domain")
+		}).optional().describe("Reuse mode: scope (model or domain required)"),
+		patches: z.array(z.object({
+			file: z.string().describe("Relative file path to patch"),
+			line: z.number().describe("Line number hint (±10 line search)"),
+			old_value: z.string().describe("Original string to replace"),
+			new_expression: z.string().describe("Replacement expression (agent-determined)"),
+			import_statement: z.string().optional().describe("Import to add if needed")
+		})).optional().describe("Reuse mode: patches to apply (max 100)")
+	}, async (input) => {
+		if (!await readConfig(projectRoot)) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: "Project not initialized. Run contentrain_init first." })
+			}],
+			isError: true
+		};
+		try {
+			switch (input.mode) {
+				case "extract": {
+					if (!input.extractions || input.extractions.length === 0) return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({ error: "Extract mode requires extractions array" })
+						}],
+						isError: true
+					};
+					const result = await applyExtract(projectRoot, {
+						extractions: input.extractions.map((e) => ({
+							...e,
+							fields: e.fields
+						})),
+						dry_run: input.dry_run
+					});
+					if (result.error !== void 0) return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({
+								mode: "extract",
+								...result
+							}, null, 2)
+						}],
+						isError: true
+					};
+					return { content: [{
+						type: "text",
+						text: JSON.stringify({
+							mode: "extract",
+							...result
+						}, null, 2)
+					}] };
+				}
+				case "reuse": {
+					if (!input.scope) return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({ error: "Reuse mode requires scope (model or domain)" })
+						}],
+						isError: true
+					};
+					if (!input.patches || input.patches.length === 0) return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({ error: "Reuse mode requires patches array" })
+						}],
+						isError: true
+					};
+					const result = await applyReuse(projectRoot, {
+						scope: input.scope,
+						patches: input.patches,
+						dry_run: input.dry_run
+					});
+					if (result.error !== void 0) return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({
+								mode: "reuse",
+								...result
+							}, null, 2)
+						}],
+						isError: true
+					};
+					return { content: [{
+						type: "text",
+						text: JSON.stringify({
+							mode: "reuse",
+							...result
+						}, null, 2)
+					}] };
+				}
+				default: return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: `Unknown mode: ${input.mode}` })
+					}],
+					isError: true
+				};
+			}
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: `Apply failed: ${error instanceof Error ? error.message : String(error)}` })
+				}],
+				isError: true
+			};
+		}
+	});
+}
+//#endregion
+//#region src/tools/bulk.ts
+function registerBulkTools(server, projectRoot) {
+	server.tool("contentrain_bulk", "Batch operations on content entries. All operations are auto-committed to git.", {
+		operation: z.enum([
+			"copy_locale",
+			"update_status",
+			"delete_entries"
+		]),
+		model: z.string().describe("Model ID"),
+		source_locale: z.string().optional().describe("Source locale for copy_locale operation"),
+		target_locale: z.string().optional().describe("Target locale for copy_locale operation"),
+		entry_ids: z.array(z.string()).optional().describe("Entry IDs for update_status or delete_entries"),
+		status: z.enum([
+			"draft",
+			"in_review",
+			"published",
+			"rejected",
+			"archived"
+		]).optional().describe("New status for update_status"),
+		confirm: z.boolean().optional().describe("Must be true for delete_entries")
+	}, async (input) => {
+		const config = await readConfig(projectRoot);
+		if (!config) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: "Project not initialized. Run contentrain_init first." })
+			}],
+			isError: true
+		};
+		const model = await readModel(projectRoot, input.model);
+		if (!model) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: `Model "${input.model}" not found` })
+			}],
+			isError: true
+		};
+		const health = await checkBranchHealth(projectRoot);
+		if (health.blocked) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({
+					error: health.message,
+					action: "blocked",
+					hint: "Merge or delete old contentrain/* branches before creating new ones."
+				}, null, 2)
+			}],
+			isError: true
+		};
+		switch (input.operation) {
+			case "copy_locale": {
+				if (!input.source_locale || !input.target_locale) return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: "copy_locale requires source_locale and target_locale" })
+					}],
+					isError: true
+				};
+				if (!config.locales.supported.includes(input.source_locale)) return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: `Source locale "${input.source_locale}" is not supported. Supported: [${config.locales.supported.join(", ")}]` })
+					}],
+					isError: true
+				};
+				if (!config.locales.supported.includes(input.target_locale)) return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: `Target locale "${input.target_locale}" is not supported. Supported: [${config.locales.supported.join(", ")}]` })
+					}],
+					isError: true
+				};
+				if (!model.i18n) return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: `Model "${input.model}" has i18n disabled. copy_locale only works with i18n-enabled models. Enable i18n first with contentrain_model_save.` })
+					}],
+					isError: true
+				};
+				if (model.kind !== "collection" && model.kind !== "singleton" && model.kind !== "dictionary") return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: "copy_locale is only supported for collection, singleton, and dictionary models" })
+					}],
+					isError: true
+				};
+				const branch = buildBranchName("bulk", input.model, input.target_locale);
+				const tx = await createTransaction(projectRoot, branch);
+				try {
+					let copiedCount = 0;
+					await tx.write(async (wt) => {
+						const cDir = resolveContentDir(wt, model);
+						const sourceFile = resolveJsonFilePath(cDir, model, input.source_locale);
+						const targetFile = resolveJsonFilePath(cDir, model, input.target_locale);
+						const sourceData = await readJson(sourceFile);
+						if (!sourceData) throw new Error(`No content found for locale "${input.source_locale}" in model "${input.model}"`);
+						await writeJson(targetFile, sourceData);
+						if (model.kind === "collection") {
+							const entries = sourceData;
+							const entryIds = Object.keys(entries);
+							const metaOps = entryIds.map((entryId) => writeMeta(wt, model, {
+								locale: input.target_locale,
+								entryId
+							}, {
+								status: "draft",
+								source: "agent",
+								updated_by: "contentrain-mcp"
+							}));
+							await Promise.all(metaOps);
+							copiedCount = entryIds.length;
+						} else {
+							await writeMeta(wt, model, { locale: input.target_locale }, {
+								status: "draft",
+								source: "agent",
+								updated_by: "contentrain-mcp"
+							});
+							copiedCount = 1;
+						}
+					});
+					await tx.commit(`[contentrain] bulk: copy ${input.source_locale} → ${input.target_locale} for ${input.model}`);
+					const gitResult = await tx.complete({
+						tool: "contentrain_bulk",
+						model: input.model,
+						locale: input.target_locale
+					});
+					return { content: [{
+						type: "text",
+						text: JSON.stringify({
+							status: "committed",
+							operation: "copy_locale",
+							message: `Copied ${copiedCount} entries from ${input.source_locale} to ${input.target_locale}.`,
+							copied: copiedCount,
+							git: {
+								branch,
+								action: gitResult.action,
+								commit: gitResult.commit
+							},
+							context_updated: true
+						}, null, 2)
+					}] };
+				} catch (error) {
+					await tx.cleanup();
+					return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({ error: `copy_locale failed: ${error instanceof Error ? error.message : String(error)}` })
+						}],
+						isError: true
+					};
+				} finally {
+					await tx.cleanup();
+				}
+			}
+			case "update_status": {
+				if (!input.entry_ids || input.entry_ids.length === 0) return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: "update_status requires entry_ids" })
+					}],
+					isError: true
+				};
+				if (!input.status) return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: "update_status requires status" })
+					}],
+					isError: true
+				};
+				if (model.kind !== "collection") return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: "update_status with entry_ids is only supported for collection models" })
+					}],
+					isError: true
+				};
+				const branch = buildBranchName("bulk", input.model);
+				const tx = await createTransaction(projectRoot, branch);
+				try {
+					let updatedCount = 0;
+					const notFound = [];
+					await tx.write(async (wt) => {
+						for (const locale of config.locales.supported) {
+							const metaData = await readMeta(wt, model, { locale });
+							const updateOps = [];
+							for (const entryId of input.entry_ids) {
+								const existing = metaData?.[entryId];
+								if (existing) {
+									updateOps.push(writeMeta(wt, model, {
+										locale,
+										entryId
+									}, {
+										...existing,
+										status: input.status,
+										updated_by: "contentrain-mcp"
+									}));
+									updatedCount++;
+								} else if (locale === config.locales.default) notFound.push(entryId);
+							}
+							await Promise.all(updateOps);
+						}
+					});
+					await tx.commit(`[contentrain] bulk: update status → ${input.status} for ${input.model}`);
+					const gitResult = await tx.complete({
+						tool: "contentrain_bulk",
+						model: input.model,
+						entries: input.entry_ids
+					});
+					return { content: [{
+						type: "text",
+						text: JSON.stringify({
+							status: "committed",
+							operation: "update_status",
+							message: `Updated ${updatedCount} meta entries to status "${input.status}".`,
+							updated: updatedCount,
+							not_found: notFound.length > 0 ? notFound : void 0,
+							git: {
+								branch,
+								action: gitResult.action,
+								commit: gitResult.commit
+							},
+							context_updated: true
+						}, null, 2)
+					}] };
+				} catch (error) {
+					await tx.cleanup();
+					return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({ error: `update_status failed: ${error instanceof Error ? error.message : String(error)}` })
+						}],
+						isError: true
+					};
+				} finally {
+					await tx.cleanup();
+				}
+			}
+			case "delete_entries": {
+				if (!input.entry_ids || input.entry_ids.length === 0) return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: "delete_entries requires entry_ids" })
+					}],
+					isError: true
+				};
+				if (input.confirm !== true) return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: "delete_entries requires confirm:true" })
+					}],
+					isError: true
+				};
+				if (model.kind !== "collection") return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({ error: "delete_entries with entry_ids is only supported for collection models" })
+					}],
+					isError: true
+				};
+				const branch = buildBranchName("bulk", input.model);
+				const tx = await createTransaction(projectRoot, branch);
+				try {
+					const allRemoved = [];
+					await tx.write(async (wt) => {
+						for (const entryId of input.entry_ids) {
+							const removed = await deleteContent(wt, model, { id: entryId });
+							allRemoved.push(...removed);
+						}
+					});
+					await tx.commit(`[contentrain] bulk: delete ${input.entry_ids.length} entries from ${input.model}`);
+					const gitResult = await tx.complete({
+						tool: "contentrain_bulk",
+						model: input.model,
+						entries: input.entry_ids
+					});
+					return { content: [{
+						type: "text",
+						text: JSON.stringify({
+							status: "committed",
+							operation: "delete_entries",
+							message: `Deleted ${input.entry_ids.length} entries.`,
+							deleted: input.entry_ids.length,
+							files_removed: allRemoved,
+							git: {
+								branch,
+								action: gitResult.action,
+								commit: gitResult.commit
+							},
+							context_updated: true
+						}, null, 2)
+					}] };
+				} catch (error) {
+					await tx.cleanup();
+					return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({ error: `delete_entries failed: ${error instanceof Error ? error.message : String(error)}` })
+						}],
+						isError: true
+					};
+				} finally {
+					await tx.cleanup();
+				}
+			}
+			default: return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: `Unknown operation: ${input.operation}` })
+				}],
+				isError: true
+			};
+		}
+	});
+}
+//#endregion
+//#region package.json
+var version = "1.0.3";
+//#endregion
+//#region src/server.ts
+function createServer(projectRoot) {
+	const server = new McpServer({
+		name: "contentrain-mcp",
+		version
+	});
+	registerContextTools(server, projectRoot);
+	registerSetupTools(server, projectRoot);
+	registerModelTools(server, projectRoot);
+	registerContentTools(server, projectRoot);
+	registerWorkflowTools(server, projectRoot);
+	registerNormalizeTools(server, projectRoot);
+	registerBulkTools(server, projectRoot);
+	return server;
+}
+//#endregion
+export { createServer as t };
+
+//# sourceMappingURL=server-CC12z_xq.mjs.map