@contentrain/mcp 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1488 @@
+#!/usr/bin/env node
+import { a as removeDir, i as listJsonFiles, n as fileExists, o as removeFile, t as ensureDir } from "./fs-D83-Ii_y.mjs";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { dirname, join } from "node:path";
+import { cp, mkdtemp, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { randomBytes, randomUUID } from "node:crypto";
+import { simpleGit } from "simple-git";
+import { z } from "zod";
+//#region src/util/json.ts
+/**
+* Read and parse a JSON file. Returns empty array if file doesn't exist.
+*/
+async function readJsonFile(filePath) {
+	try {
+		const raw = await readFile(filePath, "utf-8");
+		return JSON.parse(raw);
+	} catch (err) {
+		if (err instanceof Error && "code" in err && err.code === "ENOENT") return [];
+		throw err;
+	}
+}
+/**
+* Write JSON to file atomically (temp file + rename).
+*/
+async function writeJsonFile(filePath, data) {
+	await ensureDir(dirname(filePath));
+	const tmpPath = join(dirname(filePath), `.tmp-${randomBytes(4).toString("hex")}.json`);
+	await writeFile(tmpPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+	await rename(tmpPath, filePath);
+}
+//#endregion
+//#region src/errors.ts
+var ContentrainError = class extends Error {
+	code;
+	context;
+	constructor(message, code, context = {}) {
+		super(message);
+		this.name = "ContentrainError";
+		this.code = code;
+		this.context = context;
+	}
+};
+var ModelNotFoundError = class extends ContentrainError {
+	constructor(modelId) {
+		super(`Model not found: ${modelId}`, "MODEL_NOT_FOUND", { modelId });
+		this.name = "ModelNotFoundError";
+	}
+};
+var EntryNotFoundError = class extends ContentrainError {
+	constructor(modelId, entryId) {
+		super(`Entry not found: ${entryId} in model ${modelId}`, "ENTRY_NOT_FOUND", {
+			modelId,
+			entryId
+		});
+		this.name = "EntryNotFoundError";
+	}
+};
+var GitSyncError = class extends ContentrainError {
+	constructor(message, context = {}) {
+		super(message, "GIT_SYNC_ERROR", context);
+		this.name = "GitSyncError";
+	}
+};
+var PushRejectedError = class extends GitSyncError {
+	attemptsExhausted;
+	constructor(attemptsExhausted) {
+		super(attemptsExhausted ? "Push rejected: all retry attempts exhausted" : "Push rejected by remote", { attemptsExhausted });
+		this.name = "PushRejectedError";
+		this.attemptsExhausted = attemptsExhausted;
+	}
+};
+var AssetNotFoundError = class extends ContentrainError {
+	constructor(assetPath) {
+		super(`Asset not found in registry: ${assetPath}`, "ASSET_NOT_FOUND", { assetPath });
+		this.name = "AssetNotFoundError";
+	}
+};
+//#endregion
+//#region src/core/model/system-fields.ts
+/**
+* Generate the 4 required system fields for a model.
+*/
+function createSystemFields(modelId) {
+	return [
+		{
+			name: "createdAt",
+			fieldId: "createdAt",
+			componentId: "date",
+			options: {},
+			validations: { "required-field": { value: true } },
+			fieldType: "date",
+			system: true,
+			defaultField: false,
+			modelId
+		},
+		{
+			name: "updatedAt",
+			fieldId: "updatedAt",
+			componentId: "date",
+			options: {},
+			validations: { "required-field": { value: true } },
+			fieldType: "date",
+			system: true,
+			defaultField: false,
+			modelId
+		},
+		{
+			name: "ID",
+			fieldId: "ID",
+			componentId: "single-line-text",
+			options: {},
+			validations: { "required-field": { value: true } },
+			fieldType: "string",
+			system: true,
+			defaultField: false,
+			modelId
+		},
+		{
+			name: "status",
+			fieldId: "status",
+			componentId: "single-line-text",
+			options: {},
+			validations: { "required-field": { value: true } },
+			fieldType: "string",
+			system: true,
+			defaultField: false,
+			modelId
+		}
+	];
+}
+/**
+* Generate MD/MDX default fields (slug + content).
+*/
+function createMdDefaultFields(modelId) {
+	return [{
+		name: "slug",
+		fieldId: "slug",
+		componentId: "slug",
+		options: {},
+		validations: {
+			"required-field": { value: true },
+			"unique-field": { value: true }
+		},
+		fieldType: "string",
+		system: false,
+		defaultField: true,
+		modelId
+	}, {
+		name: "content",
+		fieldId: "content",
+		componentId: "md-editor",
+		options: {},
+		validations: { "required-field": { value: false } },
+		fieldType: "string",
+		system: false,
+		defaultField: true,
+		modelId
+	}];
+}
+//#endregion
+//#region src/core/model/manager.ts
+var ModelManager = class {
+	constructor(basePath) {
+		this.basePath = basePath;
+	}
+	get modelsDir() {
+		return join(this.basePath, "models");
+	}
+	get metadataPath() {
+		return join(this.modelsDir, "metadata.json");
+	}
+	async list() {
+		return readJsonFile(this.metadataPath);
+	}
+	async get(modelId) {
+		const model = (await this.list()).find((m) => m.modelId === modelId);
+		if (!model) throw new ModelNotFoundError(modelId);
+		return model;
+	}
+	async getFields(modelId) {
+		await this.get(modelId);
+		return readJsonFile(join(this.modelsDir, `${modelId}.json`));
+	}
+	async describe(modelId) {
+		const model = await this.get(modelId);
+		const fields = await this.getFields(modelId);
+		return {
+			model,
+			fields,
+			customFields: fields.filter((f) => !f.system && !f.defaultField)
+		};
+	}
+	async create(input) {
+		const models = await this.list();
+		if (models.some((m) => m.modelId === input.modelId)) throw new Error(`Model already exists: ${input.modelId}`);
+		const metadata = {
+			name: input.name,
+			description: input.description,
+			modelId: input.modelId,
+			path: input.path,
+			localization: input.localization,
+			type: input.type,
+			createdBy: "user",
+			isServerless: false
+		};
+		models.push(metadata);
+		await writeJsonFile(this.metadataPath, models);
+		const systemFields = createSystemFields(input.modelId);
+		const mdFields = input.type === "MD" || input.type === "MDX" ? createMdDefaultFields(input.modelId) : [];
+		const customFields = (input.fields || []).map((f) => ({
+			...f,
+			modelId: input.modelId,
+			system: false,
+			defaultField: false
+		}));
+		const allFields = [
+			...systemFields,
+			...mdFields,
+			...customFields
+		];
+		await ensureDir(this.modelsDir);
+		await writeJsonFile(join(this.modelsDir, `${input.modelId}.json`), allFields);
+		const contentDir = join(this.basePath, input.modelId);
+		await ensureDir(contentDir);
+		if (input.localization) {} else await writeJsonFile(join(contentDir, `${input.modelId}.json`), []);
+		return metadata;
+	}
+	async addField(modelId, field) {
+		const fields = await this.getFields(modelId);
+		if (fields.some((f) => f.fieldId === field.fieldId)) throw new Error(`Field already exists: ${field.fieldId} in model ${modelId}`);
+		const newField = {
+			...field,
+			modelId,
+			system: false,
+			defaultField: false
+		};
+		fields.push(newField);
+		await writeJsonFile(join(this.modelsDir, `${modelId}.json`), fields);
+		return newField;
+	}
+	async removeField(modelId, fieldId) {
+		const fields = await this.getFields(modelId);
+		const field = fields.find((f) => f.fieldId === fieldId);
+		if (!field) throw new Error(`Field not found: ${fieldId} in model ${modelId}`);
+		if (field.system) throw new Error(`Cannot remove system field: ${fieldId}`);
+		const filtered = fields.filter((f) => f.fieldId !== fieldId);
+		await writeJsonFile(join(this.modelsDir, `${modelId}.json`), filtered);
+	}
+	async delete(modelId) {
+		const models = await this.list();
+		const filtered = models.filter((m) => m.modelId !== modelId);
+		if (filtered.length === models.length) throw new ModelNotFoundError(modelId);
+		await writeJsonFile(this.metadataPath, filtered);
+		const { removeFile, removeDir } = await import("./fs-D83-Ii_y.mjs").then((n) => n.r);
+		await removeFile(join(this.modelsDir, `${modelId}.json`));
+		await removeDir(join(this.basePath, modelId));
+	}
+};
+//#endregion
+//#region src/util/id.ts
+const ID_PATTERN = /^[a-f0-9]{12}$/;
+/**
+* Generate a 12-character lowercase hexadecimal ID.
+* Matches the Contentrain platform: crypto.randomUUID().split('-').pop()
+*/
+function generateId() {
+	return randomUUID().split("-").pop();
+}
+/**
+* Validate that a string matches the Contentrain ID format.
+*/
+function isValidId(id) {
+	return ID_PATTERN.test(id);
+}
+//#endregion
+//#region src/core/content/markdown.ts
+/**
+* Build frontmatter string from entry data (excluding 'content' field).
+*/
+function buildFrontmatter(entry) {
+	const lines = ["---"];
+	for (const [key, value] of Object.entries(entry)) {
+		if (key === "content") continue;
+		if (typeof value === "string") lines.push(`${key}: '${value}'`);
+		else if (typeof value === "boolean" || typeof value === "number") lines.push(`${key}: ${value}`);
+		else if (Array.isArray(value)) lines.push(`${key}: ${JSON.stringify(value)}`);
+	}
+	lines.push("---");
+	return lines.join("\n");
+}
+/**
+* Get the markdown file extension based on model type.
+*/
+function getExtension(type) {
+	return type === "MDX" ? ".mdx" : ".md";
+}
+/**
+* Resolve the markdown file path for an entry.
+*/
+function resolveMarkdownPath(repoPath, model, entry, locale) {
+	const basePath = entry.path || model.path || "";
+	const ext = getExtension(model.type);
+	if (locale) return join(repoPath, basePath, locale, `${entry.slug}${ext}`);
+	return join(repoPath, basePath, `${entry.slug}${ext}`);
+}
+var MarkdownSync = class {
+	constructor(repoPath) {
+		this.repoPath = repoPath;
+	}
+	/**
+	* Write a markdown file for an MD/MDX entry.
+	*/
+	async write(model, entry, content, locale) {
+		const filePath = resolveMarkdownPath(this.repoPath, model, entry, locale);
+		await ensureDir(join(filePath, ".."));
+		await writeFile(filePath, `${buildFrontmatter(entry)}\n\n${content || ""}\n`, "utf-8");
+		return filePath;
+	}
+	/**
+	* Read markdown content from a file.
+	*/
+	async read(model, entry, locale) {
+		const filePath = resolveMarkdownPath(this.repoPath, model, entry, locale);
+		try {
+			const match = (await readFile(filePath, "utf-8")).match(/^---\n[\s\S]*?\n---\n\n?([\s\S]*)$/);
+			return match ? match[1].trim() : "";
+		} catch {
+			return "";
+		}
+	}
+	/**
+	* Delete a markdown file for an entry.
+	*/
+	async delete(model, entry, locale) {
+		await removeFile(resolveMarkdownPath(this.repoPath, model, entry, locale));
+	}
+};
+//#endregion
+//#region src/core/content/manager.ts
+var ContentManager = class {
+	modelManager;
+	markdownSync;
+	constructor(basePath, repoPath) {
+		this.basePath = basePath;
+		this.repoPath = repoPath;
+		this.modelManager = new ModelManager(basePath);
+		this.markdownSync = new MarkdownSync(repoPath);
+	}
+	contentDir(modelId) {
+		return join(this.basePath, modelId);
+	}
+	contentFilePath(modelId, locale) {
+		const dir = this.contentDir(modelId);
+		return locale ? join(dir, `${locale}.json`) : join(dir, `${modelId}.json`);
+	}
+	async list(modelId, locale) {
+		const model = await this.modelManager.get(modelId);
+		return readJsonFile(this.resolveContentPath(model, locale));
+	}
+	async get(modelId, entryId, locale) {
+		const entry = (await this.list(modelId, locale)).find((e) => e.ID === entryId);
+		if (!entry) throw new EntryNotFoundError(modelId, entryId);
+		return entry;
+	}
+	async getLocales(modelId) {
+		if (!(await this.modelManager.get(modelId)).localization) return [];
+		return (await listJsonFiles(this.contentDir(modelId))).filter((f) => f !== modelId);
+	}
+	async create(modelId, data, options) {
+		const model = await this.modelManager.get(modelId);
+		const id = options?.id || generateId();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const entry = {
+			ID: id,
+			createdAt: now,
+			updatedAt: now,
+			status: options?.status || "draft",
+			scheduled: false,
+			...data
+		};
+		if (model.localization) await this.createLocalized(model, entry, options?.locale, options?.content);
+		else await this.appendEntry(model, entry, void 0, options?.content);
+		return id;
+	}
+	async update(modelId, entryId, data, options) {
+		const model = await this.modelManager.get(modelId);
+		const locale = model.localization ? options?.locale : void 0;
+		const filePath = this.resolveContentPath(model, locale);
+		const entries = await readJsonFile(filePath);
+		const index = entries.findIndex((e) => e.ID === entryId);
+		if (index === -1) throw new EntryNotFoundError(modelId, entryId);
+		const updated = {
+			...entries[index],
+			...data,
+			ID: entryId,
+			createdAt: entries[index].createdAt,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		entries[index] = updated;
+		await writeJsonFile(filePath, entries);
+		if ((model.type === "MD" || model.type === "MDX") && "slug" in updated) {
+			const mdContent = options?.content ?? await this.markdownSync.read(model, updated, locale);
+			await this.markdownSync.write(model, updated, mdContent, locale);
+		}
+		return updated;
+	}
+	async delete(modelId, entryId) {
+		const model = await this.modelManager.get(modelId);
+		if (model.localization) {
+			const locales = await this.getLocales(modelId);
+			for (const locale of locales) await this.deleteFromFile(model, entryId, locale);
+		} else await this.deleteFromFile(model, entryId);
+	}
+	resolveContentPath(model, locale) {
+		if (model.localization && locale) return this.contentFilePath(model.modelId, locale);
+		if (model.localization && !locale) return this.contentFilePath(model.modelId, model.modelId);
+		return this.contentFilePath(model.modelId);
+	}
+	async createLocalized(model, entry, locale, content) {
+		if (locale) await this.appendEntry(model, entry, locale, content);
+		else {
+			const locales = await this.getLocales(model.modelId);
+			if (locales.length === 0) throw new Error(`Model "${model.modelId}" is localized but no locale files exist. Specify a locale (e.g., locale: "en") to create the first entry.`);
+			for (const loc of locales) await this.appendEntry(model, entry, loc, content);
+		}
+	}
+	async appendEntry(model, entry, locale, content) {
+		const filePath = this.resolveContentPath(model, locale);
+		await ensureDir(join(filePath, ".."));
+		const entries = await readJsonFile(filePath);
+		if (entries.some((e) => e.ID === entry.ID)) throw new Error(`Duplicate ID: ${entry.ID} already exists in ${model.modelId}`);
+		entries.push(entry);
+		await writeJsonFile(filePath, entries);
+		if ((model.type === "MD" || model.type === "MDX") && "slug" in entry) await this.markdownSync.write(model, entry, content || "", locale);
+	}
+	async deleteFromFile(model, entryId, locale) {
+		const filePath = this.resolveContentPath(model, locale);
+		const entries = await readJsonFile(filePath);
+		const entry = entries.find((e) => e.ID === entryId);
+		if (!entry) return;
+		await writeJsonFile(filePath, entries.filter((e) => e.ID !== entryId));
+		if ((model.type === "MD" || model.type === "MDX") && "slug" in entry) await this.markdownSync.delete(model, entry, locale);
+	}
+};
+//#endregion
+//#region src/core/asset/manager.ts
+var AssetManager = class {
+	assetsPath;
+	constructor(basePath, repoPath, config) {
+		this.basePath = basePath;
+		this.repoPath = repoPath;
+		this.config = config;
+		this.assetsPath = join(basePath, "assets.json");
+	}
+	async list() {
+		return readJsonFile(this.assetsPath);
+	}
+	async get(assetPath) {
+		return (await this.list()).find((a) => a.path === assetPath);
+	}
+	async register(input) {
+		const fullPath = join(this.repoPath, input.path);
+		if (!await fileExists(fullPath)) throw new Error(`Asset file does not exist at: ${input.path}`);
+		const assets = await this.list();
+		if (assets.some((a) => a.path === input.path)) throw new Error(`Asset already registered: ${input.path}`);
+		const stats = await stat(fullPath);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const entry = {
+			path: input.path,
+			mimetype: input.mimetype,
+			size: stats.size,
+			alt: input.alt || "",
+			meta: {
+				user: {
+					name: this.config.author?.name || "AI Agent",
+					email: this.config.author?.email || "agent@contentrain.io"
+				},
+				createdAt: now,
+				updatedAt: now
+			}
+		};
+		assets.push(entry);
+		await writeJsonFile(this.assetsPath, assets);
+		return entry;
+	}
+	async deregister(assetPath) {
+		const assets = await this.list();
+		const filtered = assets.filter((a) => a.path !== assetPath);
+		if (filtered.length === assets.length) throw new AssetNotFoundError(assetPath);
+		await writeJsonFile(this.assetsPath, filtered);
+	}
+	async update(assetPath, updates) {
+		const assets = await this.list();
+		const index = assets.findIndex((a) => a.path === assetPath);
+		if (index === -1) throw new AssetNotFoundError(assetPath);
+		if (updates.alt !== void 0) assets[index].alt = updates.alt;
+		if (updates.mimetype !== void 0) assets[index].mimetype = updates.mimetype;
+		if (assets[index].meta) assets[index].meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		await writeJsonFile(this.assetsPath, assets);
+		return assets[index];
+	}
+};
+//#endregion
+//#region src/core/validation/rules.ts
+const VALID_STATUSES = [
+	"draft",
+	"publish",
+	"changed"
+];
+/**
+* Map componentId to expected runtime JS type.
+*/
+function getExpectedType(componentId, fieldType) {
+	switch (componentId) {
+		case "single-line-text":
+		case "multi-line-text":
+		case "email":
+		case "url":
+		case "slug":
+		case "color":
+		case "json":
+		case "md-editor":
+		case "rich-text-editor":
+		case "phone-number": return "string";
+		case "integer":
+		case "decimal":
+		case "rating":
+		case "percent": return "number";
+		case "checkbox":
+		case "switch": return "boolean";
+		case "date":
+		case "date-time": return "string";
+		case "media": return "string";
+		case "one-to-one": return "string";
+		case "one-to-many": return "array";
+		default: return fieldType === "array" ? "array" : "string";
+	}
+}
+/**
+* Validate an ID matches Contentrain format (12-char lowercase hex).
+*/
+function validateId(id) {
+	if (typeof id !== "string") return "ID must be a string";
+	if (!isValidId(id)) return "ID must be 12-character lowercase hexadecimal";
+	return null;
+}
+/**
+* Validate a status value.
+*/
+function validateStatus(status) {
+	if (typeof status !== "string") return "status must be a string";
+	if (!VALID_STATUSES.includes(status)) return `status must be one of: ${VALID_STATUSES.join(", ")}`;
+	return null;
+}
+/**
+* Validate a value matches the expected runtime type.
+*/
+function validateFieldValue(value, expectedType, fieldId) {
+	if (value === null || value === void 0) return null;
+	switch (expectedType) {
+		case "string":
+			if (typeof value !== "string") return `${fieldId} must be a string`;
+			break;
+		case "number":
+			if (typeof value !== "number") return `${fieldId} must be a number`;
+			break;
+		case "boolean":
+			if (typeof value !== "boolean") return `${fieldId} must be a boolean`;
+			break;
+		case "array":
+			if (!Array.isArray(value)) return `${fieldId} must be an array`;
+			break;
+	}
+	return null;
+}
+/**
+* Validate integer specifically.
+*/
+function validateInteger(value, fieldId) {
+	if (typeof value === "number" && !Number.isInteger(value)) return `${fieldId} must be an integer`;
+	return null;
+}
+//#endregion
+//#region src/core/validation/validator.ts
+var Validator = class {
+	modelManager;
+	constructor(basePath) {
+		this.basePath = basePath;
+		this.modelManager = new ModelManager(basePath);
+	}
+	/**
+	* Validate content data against model field definitions.
+	*/
+	async validate(modelId, data, options) {
+		const errors = [];
+		const { fields, model } = await this.modelManager.describe(modelId);
+		const nonSystemFields = fields.filter((f) => !f.system);
+		for (const field of nonSystemFields) {
+			const value = data[field.fieldId];
+			if (field.validations?.["required-field"]?.value) {
+				if (!options?.isUpdate && (value === void 0 || value === null || value === "")) {
+					if (field.fieldId === "content" && (model.type === "MD" || model.type === "MDX")) continue;
+					errors.push({
+						fieldId: field.fieldId,
+						message: `${field.name} is required`,
+						rule: "required-field"
+					});
+					continue;
+				}
+			}
+			if (value === void 0 || value === null) continue;
+			const typeError = validateFieldValue(value, getExpectedType(field.componentId, field.fieldType), field.fieldId);
+			if (typeError) {
+				errors.push({
+					fieldId: field.fieldId,
+					message: typeError,
+					rule: "type-check"
+				});
+				continue;
+			}
+			if (field.componentId === "integer") {
+				const intError = validateInteger(value, field.fieldId);
+				if (intError) errors.push({
+					fieldId: field.fieldId,
+					message: intError,
+					rule: "integer-check"
+				});
+			}
+			if (field.componentId === "one-to-one" && typeof value === "string") {
+				const refModel = field.options?.reference?.form?.reference?.value;
+				if (refModel) {
+					const integrityError = await this.checkRelationIntegrity(refModel, value);
+					if (integrityError) errors.push({
+						fieldId: field.fieldId,
+						message: integrityError,
+						rule: "relation-integrity"
+					});
+				}
+			}
+			if (field.componentId === "one-to-many" && Array.isArray(value)) {
+				const refModel = field.options?.reference?.form?.reference?.value;
+				if (refModel) {
+					for (const refId of value) if (typeof refId === "string") {
+						const integrityError = await this.checkRelationIntegrity(refModel, refId);
+						if (integrityError) errors.push({
+							fieldId: field.fieldId,
+							message: integrityError,
+							rule: "relation-integrity"
+						});
+					}
+				}
+			}
+			if (field.componentId === "media" && typeof value === "string" && value !== "") {
+				const assetError = await this.checkAssetExists(value);
+				if (assetError) errors.push({
+					fieldId: field.fieldId,
+					message: assetError,
+					rule: "asset-exists"
+				});
+			}
+		}
+		if (!options?.isUpdate) {
+			const uniqueFields = nonSystemFields.filter((f) => f.validations?.["unique-field"]?.value);
+			for (const field of uniqueFields) {
+				const value = data[field.fieldId];
+				if (value === void 0 || value === null) continue;
+				const uniqueError = await this.checkUniqueness(modelId, field.fieldId, value);
+				if (uniqueError) errors.push({
+					fieldId: field.fieldId,
+					message: uniqueError,
+					rule: "unique-field"
+				});
+			}
+		}
+		return {
+			valid: errors.length === 0,
+			errors
+		};
+	}
+	/**
+	* Validate ID format.
+	*/
+	validateId(id) {
+		const error = validateId(id);
+		if (error) return {
+			valid: false,
+			errors: [{
+				fieldId: "ID",
+				message: error,
+				rule: "id-format"
+			}]
+		};
+		return {
+			valid: true,
+			errors: []
+		};
+	}
+	/**
+	* Validate status value.
+	*/
+	validateStatus(status) {
+		const error = validateStatus(status);
+		if (error) return {
+			valid: false,
+			errors: [{
+				fieldId: "status",
+				message: error,
+				rule: "status-value"
+			}]
+		};
+		return {
+			valid: true,
+			errors: []
+		};
+	}
+	async checkRelationIntegrity(refModelId, refEntryId) {
+		try {
+			await this.modelManager.get(refModelId);
+			const contentDir = join(this.basePath, refModelId);
+			const { listJsonFiles } = await import("./fs-D83-Ii_y.mjs").then((n) => n.r);
+			const files = await listJsonFiles(contentDir);
+			for (const file of files) if ((await readJsonFile(join(contentDir, `${file}.json`))).some((e) => e.ID === refEntryId)) return null;
+			return `Referenced entry ${refEntryId} not found in model ${refModelId}`;
+		} catch {
+			return `Referenced model ${refModelId} not found`;
+		}
+	}
+	async checkAssetExists(assetPath) {
+		try {
+			if ((await readJsonFile(join(this.basePath, "assets.json"))).some((a) => a.path === assetPath)) return null;
+			return `Asset not found in registry: ${assetPath}`;
+		} catch {
+			return `Could not read assets.json`;
+		}
+	}
+	async checkUniqueness(modelId, fieldId, value) {
+		try {
+			const contentDir = join(this.basePath, modelId);
+			const { listJsonFiles } = await import("./fs-D83-Ii_y.mjs").then((n) => n.r);
+			const files = await listJsonFiles(contentDir);
+			for (const file of files) if ((await readJsonFile(join(contentDir, `${file}.json`))).some((e) => e[fieldId] === value)) return `${fieldId} value "${value}" already exists — must be unique`;
+			return null;
+		} catch {
+			return null;
+		}
+	}
+};
+//#endregion
+//#region src/core/git/merge.ts
+/**
+* Three-way structural merge for JSON arrays indexed by ID.
+*
+* Strategy:
+* - New entries (in ours but not base): APPEND to result
+* - Deleted entries (in base but not in ours): REMOVE from result
+* - Modified entries (same ID, different fields): apply our field-level changes over theirs
+* - Entries only in theirs (added by another writer): KEEP
+*/
+function structuralMerge(base, ours, theirs) {
+	const baseMap = indexById(base);
+	const oursMap = indexById(ours);
+	const result = [];
+	const processedIds = /* @__PURE__ */ new Set();
+	for (const theirEntry of theirs) {
+		const id = theirEntry.ID;
+		processedIds.add(id);
+		const baseEntry = baseMap.get(id);
+		const ourEntry = oursMap.get(id);
+		if (!ourEntry && baseEntry) continue;
+		if (ourEntry && baseEntry) result.push(mergeEntry(baseEntry, ourEntry, theirEntry));
+		else result.push(theirEntry);
+	}
+	for (const ourEntry of ours) if (!processedIds.has(ourEntry.ID)) result.push(ourEntry);
+	return result;
+}
+/**
+* Merge a single entry using three-way field comparison.
+* Our changes take precedence over theirs when both modified the same field.
+*/
+function mergeEntry(base, ours, theirs) {
+	const merged = { ...theirs };
+	for (const key of Object.keys(ours)) {
+		const baseVal = JSON.stringify(base[key]);
+		const ourVal = JSON.stringify(ours[key]);
+		const theirVal = JSON.stringify(theirs[key]);
+		if (ourVal !== baseVal && theirVal === baseVal) merged[key] = ours[key];
+		else if (ourVal !== baseVal && theirVal !== baseVal) merged[key] = ours[key];
+	}
+	return merged;
+}
+function indexById(entries) {
+	const map = /* @__PURE__ */ new Map();
+	for (const entry of entries) map.set(entry.ID, entry);
+	return map;
+}
+//#endregion
+//#region src/core/git/sync.ts
+var GitSyncManager = class {
+	config;
+	constructor(config) {
+		this.config = {
+			...config,
+			remote: config.remote || "origin",
+			retryAttempts: config.retryAttempts || 3,
+			commitPrefix: config.commitPrefix || "[contentrain]"
+		};
+	}
+	/**
+	* Create an isolated git worktree for safe operations.
+	*/
+	async createWorktree() {
+		const id = randomBytes(4).toString("hex");
+		const worktreePath = join(tmpdir(), `contentrain-mcp-${id}`);
+		const git = simpleGit(this.config.repoPath);
+		try {
+			await git.fetch(this.config.remote, this.config.branch);
+			const remoteBranch = `${this.config.remote}/${this.config.branch}`;
+			const localBranch = `contentrain-work-${id}`;
+			await git.raw([
+				"worktree",
+				"add",
+				"-b",
+				localBranch,
+				worktreePath,
+				remoteBranch
+			]);
+			return {
+				path: worktreePath,
+				branch: localBranch,
+				id
+			};
+		} catch (err) {
+			throw new GitSyncError(`Failed to create worktree: ${err}`, {
+				branch: this.config.branch,
+				worktreePath
+			});
+		}
+	}
+	/**
+	* Commit all changes in the worktree.
+	*/
+	async commit(ctx, message) {
+		const git = simpleGit(ctx.path);
+		const fullMessage = `${this.config.commitPrefix} ${message}`;
+		await git.add("-A");
+		if ((await git.status()).files.length === 0) return "";
+		const authorArgs = [];
+		if (this.config.author) authorArgs.push("--author", `${this.config.author.name} <${this.config.author.email}>`);
+		return (await git.commit(fullMessage, void 0, Object.fromEntries(authorArgs.length ? [["--author", `${this.config.author.name} <${this.config.author.email}>`]] : []))).commit;
+	}
+	/**
+	* Push with rebase-retry on conflict.
+	*/
+	async pushWithRetry(ctx) {
+		const git = simpleGit(ctx.path);
+		const maxAttempts = this.config.retryAttempts;
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
+			await git.push(this.config.remote, `${ctx.branch}:${this.config.branch}`);
+			return;
+		} catch {
+			if (attempt === maxAttempts) throw new PushRejectedError(true);
+			try {
+				await this.resolveAndRetry(ctx);
+			} catch (mergeErr) {
+				if (attempt === maxAttempts) throw new GitSyncError(`Failed to resolve conflicts after ${maxAttempts} attempts`, { originalError: String(mergeErr) });
+			}
+		}
+	}
+	/**
+	* Cleanup: remove the worktree.
+	*/
+	async cleanup(ctx) {
+		try {
+			await simpleGit(this.config.repoPath).raw([
+				"worktree",
+				"remove",
+				ctx.path,
+				"--force"
+			]);
+		} catch {
+			await removeDir(ctx.path);
+		}
+		try {
+			await simpleGit(this.config.repoPath).raw([
+				"branch",
+				"-D",
+				ctx.branch
+			]);
+		} catch {}
+	}
+	/**
+	* Run a full transaction: worktree → execute → commit → push → cleanup.
+	*/
+	async transaction(fn, message) {
+		const ctx = await this.createWorktree();
+		try {
+			const result = await fn(ctx.path);
+			if (await this.commit(ctx, message)) await this.pushWithRetry(ctx);
+			return result;
+		} finally {
+			await this.cleanup(ctx);
+		}
+	}
+	/**
+	* Resolve push conflicts via structural JSON merge.
+	*/
+	async resolveAndRetry(ctx) {
+		const git = simpleGit(ctx.path);
+		const remoteBranch = `${this.config.remote}/${this.config.branch}`;
+		await git.fetch(this.config.remote, this.config.branch);
+		const baseCommit = (await git.raw([
+			"merge-base",
+			ctx.branch,
+			remoteBranch
+		])).trim();
+		const changedFiles = (await git.raw([
+			"diff",
+			"--name-only",
+			`${remoteBranch}...${ctx.branch}`
+		])).trim().split("\n").filter((f) => f.endsWith(".json"));
+		for (const file of changedFiles) {
+			if (!file.includes("contentrain/") && !file.startsWith("contentrain/")) continue;
+			try {
+				const basePath = join(ctx.path, file);
+				const base = await this.readGitVersion(git, baseCommit, file);
+				const ours = await readJsonFile(basePath);
+				const theirsRaw = await git.raw(["show", `${remoteBranch}:${file}`]);
+				await writeJsonFile(basePath, structuralMerge(base, ours, JSON.parse(theirsRaw)));
+			} catch {}
+		}
+		await git.raw([
+			"reset",
+			"--soft",
+			remoteBranch
+		]);
+		await git.add("-A");
+		if ((await git.status()).files.length > 0) await git.commit(`${this.config.commitPrefix} merge: resolve concurrent changes`);
+	}
+	async readGitVersion(git, commit, filePath) {
+		try {
+			const raw = await git.raw(["show", `${commit}:${filePath}`]);
+			return JSON.parse(raw);
+		} catch {
+			return [];
+		}
+	}
+};
+//#endregion
+//#region src/core/writer.ts
+/**
+* Main orchestrator — coordinates all managers and git sync.
+*
+* Three modes:
+* 1. Read mode: reads from repoPath directly (no git sync)
+* 2. Transaction mode: creates a worktree, applies changes, commits + pushes
+* 3. Dry-run mode: copies contentrain dir to temp, applies changes there, then discards
+*/
+var ContentrainWriter = class {
+	config;
+	contentrainDir;
+	model;
+	content;
+	asset;
+	validator;
+	gitSync;
+	constructor(config) {
+		this.config = config;
+		this.contentrainDir = config.contentrainDir || "contentrain";
+		const basePath = join(config.repoPath, this.contentrainDir);
+		this.model = new ModelManager(basePath);
+		this.content = new ContentManager(basePath, config.repoPath);
+		this.asset = new AssetManager(basePath, config.repoPath, config);
+		this.validator = new Validator(basePath);
+		this.gitSync = new GitSyncManager(config);
+	}
+	/**
+	* Execute operations in a git-synced transaction.
+	* Creates worktree → runs operations → validates → commits → pushes.
+	* In dry-run mode, copies to a temp directory and discards after execution.
+	*/
+	async transaction(fn, options) {
+		if (this.config.dryRun) return this.dryRunTransaction(fn);
+		return this.gitSync.transaction(async (worktreePath) => {
+			return fn(this.createManagers(worktreePath));
+		}, options?.message || "content update");
+	}
+	/**
+	* Dry-run: copy contentrain dir to temp, run operations there, then discard.
+	* The original repository is never modified.
+	*/
+	async dryRunTransaction(fn) {
+		const tempRepoPath = await mkdtemp(join(tmpdir(), "contentrain-dry-"));
+		const tempContentrainDir = join(tempRepoPath, this.contentrainDir);
+		const sourceContentrainDir = join(this.config.repoPath, this.contentrainDir);
+		try {
+			await cp(sourceContentrainDir, tempContentrainDir, { recursive: true });
+			return await fn(this.createManagers(tempRepoPath));
+		} finally {
+			await removeDir(tempRepoPath);
+		}
+	}
+	/**
+	* Create managers for a specific repo path (used in transactions).
+	*/
+	createManagers(repoPath) {
+		const basePath = join(repoPath, this.contentrainDir);
+		return {
+			model: new ModelManager(basePath),
+			content: new ContentManager(basePath, repoPath),
+			asset: new AssetManager(basePath, repoPath, this.config),
+			validator: new Validator(basePath)
+		};
+	}
+};
+//#endregion
+//#region src/tools/model.ts
+function registerModelTools(server, writer) {
+	server.registerTool("contentrain_list_models", { description: "List all Contentrain models with their metadata (type, localization, etc.)" }, async () => {
+		try {
+			const models = await writer.model.list();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(models, null, 2)
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err}`
+				}],
+				isError: true
+			};
+		}
+	});
+	server.registerTool("contentrain_describe_model", {
+		description: "Get detailed schema for a model including all field definitions, types, validations, and options. Call this BEFORE creating or updating content to understand required fields.",
+		inputSchema: { modelId: z.string().describe("The model ID to describe") }
+	}, async ({ modelId }) => {
+		try {
+			const desc = await writer.model.describe(modelId);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(desc, null, 2)
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err}`
+				}],
+				isError: true
+			};
+		}
+	});
+	server.registerTool("contentrain_create_model", {
+		description: "Create a new Contentrain model with field definitions. System fields (ID, createdAt, updatedAt, status) are auto-added. For MD/MDX models, slug and content fields are also auto-added.",
+		inputSchema: {
+			name: z.string().describe("Display name of the model"),
+			modelId: z.string().regex(/^[a-z0-9-]+$/).describe("Unique model ID in kebab-case"),
+			type: z.enum([
+				"JSON",
+				"MD",
+				"MDX"
+			]).describe("Content type"),
+			localization: z.boolean().describe("Whether the model supports multiple languages"),
+			description: z.string().optional().describe("Model description"),
+			path: z.string().optional().describe("Base path for MD/MDX files"),
+			fields: z.array(z.object({
+				name: z.string(),
+				fieldId: z.string(),
+				componentId: z.string(),
+				fieldType: z.string(),
+				options: z.record(z.unknown()).optional(),
+				validations: z.record(z.unknown()).optional()
+			})).optional().describe("Custom field definitions (system fields are auto-added)")
+		}
+	}, async (params) => {
+		try {
+			const result = await writer.transaction(async (tx) => {
+				return tx.model.create({
+					name: params.name,
+					modelId: params.modelId,
+					type: params.type,
+					localization: params.localization,
+					description: params.description,
+					path: params.path,
+					fields: params.fields
+				});
+			}, { message: `create model: ${params.modelId}` });
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					model: result
+				}, null, 2)
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err}`
+				}],
+				isError: true
+			};
+		}
+	});
+	server.registerTool("contentrain_add_field", {
+		description: "Add a new field to an existing model.",
+		inputSchema: {
+			modelId: z.string().describe("Target model ID"),
+			name: z.string().describe("Display name of the field"),
+			fieldId: z.string().describe("Unique field identifier"),
+			componentId: z.string().describe("UI component (single-line-text, integer, one-to-one, media, etc.)"),
+			fieldType: z.string().describe("Data type (string, number, boolean, relation, media, date, array)"),
+			options: z.record(z.unknown()).optional().describe("Field options (title-field, default-value, reference, etc.)"),
+			validations: z.record(z.unknown()).optional().describe("Field validations (required-field, unique-field)")
+		}
+	}, async (params) => {
+		try {
+			const result = await writer.transaction(async (tx) => {
+				return tx.model.addField(params.modelId, {
+					name: params.name,
+					fieldId: params.fieldId,
+					componentId: params.componentId,
+					fieldType: params.fieldType,
+					options: params.options || {},
+					validations: params.validations || {}
+				});
+			}, { message: `add field ${params.fieldId} to ${params.modelId}` });
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					field: result
+				}, null, 2)
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err}`
+				}],
+				isError: true
+			};
+		}
+	});
+	server.registerTool("contentrain_delete_model", {
+		description: "Delete a model and all its content. WARNING: This is destructive and cannot be undone.",
+		annotations: { destructiveHint: true },
+		inputSchema: { modelId: z.string().describe("Model ID to delete") }
+	}, async ({ modelId }) => {
+		try {
+			await writer.transaction(async (tx) => {
+				await tx.model.delete(modelId);
+			}, { message: `delete model: ${modelId}` });
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					deleted: modelId
+				})
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err}`
+				}],
+				isError: true
+			};
+		}
+	});
+}
+//#endregion
+//#region src/tools/content.ts
+function registerContentTools(server, writer) {
+	server.registerTool("contentrain_list_content", {
+		description: "List all content entries for a model. For localized models, specify a locale.",
+		annotations: { readOnlyHint: true },
+		inputSchema: {
+			modelId: z.string().describe("Model ID to list content from"),
+			locale: z.string().optional().describe("Locale code (e.g., \"en\", \"tr\") for localized models")
+		}
+	}, async ({ modelId, locale }) => {
+		try {
+			const entries = await writer.content.list(modelId, locale);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					total: entries.length,
+					entries
+				}, null, 2)
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err}`
+				}],
+				isError: true
+			};
+		}
+	});
+	server.registerTool("contentrain_get_content", {
+		description: "Get a single content entry by ID.",
+		annotations: { readOnlyHint: true },
+		inputSchema: {
+			modelId: z.string().describe("Model ID"),
+			entryId: z.string().describe("Entry ID (12-char hex)"),
+			locale: z.string().optional().describe("Locale code for localized models")
+		}
+	}, async ({ modelId, entryId, locale }) => {
+		try {
+			const entry = await writer.content.get(modelId, entryId, locale);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(entry, null, 2)
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err}`
+				}],
+				isError: true
+			};
+		}
+	});
+	server.registerTool("contentrain_create_content", {
+		description: "Create a new content entry. System fields (ID, createdAt, updatedAt, status) are auto-generated. For localized models, specify locale to create in that language. Call contentrain_describe_model first to know required fields.",
+		inputSchema: {
+			modelId: z.string().describe("Target model ID"),
+			data: z.record(z.unknown()).describe("Content data object with field values matching model schema"),
+			locale: z.string().optional().describe("Locale code (e.g., \"en\") — required for localized models"),
+			status: z.enum(["draft", "publish"]).optional().describe("Entry status (default: \"draft\")"),
+			content: z.string().optional().describe("Markdown body content (only for MD/MDX models)")
+		}
+	}, async (params) => {
+		try {
+			const result = await writer.transaction(async (tx) => {
+				const validation = await tx.validator.validate(params.modelId, params.data);
+				if (!validation.valid) throw new Error(`Validation failed:\n${validation.errors.map((e) => `  - ${e.fieldId}: ${e.message}`).join("\n")}`);
+				return tx.content.create(params.modelId, params.data, {
+					locale: params.locale,
+					status: params.status,
+					content: params.content
+				});
+			}, { message: `create ${params.modelId} entry` });
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					id: result
+				}, null, 2)
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err}`
+				}],
+				isError: true
+			};
+		}
+	});
+	server.registerTool("contentrain_update_content", {
+		description: "Update an existing content entry. Only provide fields you want to change. updatedAt is auto-set.",
+		inputSchema: {
+			modelId: z.string().describe("Model ID"),
+			entryId: z.string().describe("Entry ID to update (12-char hex)"),
+			data: z.record(z.unknown()).describe("Fields to update"),
+			locale: z.string().optional().describe("Locale code for localized models"),
+			content: z.string().optional().describe("Updated markdown body (only for MD/MDX models)")
+		}
+	}, async (params) => {
+		try {
+			const result = await writer.transaction(async (tx) => {
+				const validation = await tx.validator.validate(params.modelId, params.data, { isUpdate: true });
+				if (!validation.valid) throw new Error(`Validation failed:\n${validation.errors.map((e) => `  - ${e.fieldId}: ${e.message}`).join("\n")}`);
+				return tx.content.update(params.modelId, params.entryId, params.data, {
+					locale: params.locale,
+					content: params.content
+				});
+			}, { message: `update ${params.modelId}/${params.entryId}` });
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					entry: result
+				}, null, 2)
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err}`
+				}],
+				isError: true
+			};
+		}
+	});
+	server.registerTool("contentrain_delete_content", {
+		description: "Delete a content entry by ID. For localized models, removes from all locale files. For MD/MDX, also deletes markdown files.",
+		annotations: { destructiveHint: true },
+		inputSchema: {
+			modelId: z.string().describe("Model ID"),
+			entryId: z.string().describe("Entry ID to delete (12-char hex)")
+		}
+	}, async ({ modelId, entryId }) => {
+		try {
+			await writer.transaction(async (tx) => {
+				await tx.content.delete(modelId, entryId);
+			}, { message: `delete ${modelId}/${entryId}` });
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					deleted: entryId
+				})
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err}`
+				}],
+				isError: true
+			};
+		}
+	});
+	server.registerTool("contentrain_validate", {
+		description: "Validate content data against model schema without writing. Use for dry-run checks.",
+		annotations: { readOnlyHint: true },
+		inputSchema: {
+			modelId: z.string().describe("Model ID to validate against"),
+			data: z.record(z.unknown()).describe("Content data to validate")
+		}
+	}, async ({ modelId, data }) => {
+		try {
+			const result = await writer.validator.validate(modelId, data);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err}`
+				}],
+				isError: true
+			};
+		}
+	});
+}
+//#endregion
+//#region src/tools/asset.ts
+function registerAssetTools(server, writer) {
+	server.registerTool("contentrain_list_assets", {
+		description: "List all registered assets in assets.json.",
+		annotations: { readOnlyHint: true }
+	}, async () => {
+		try {
+			const assets = await writer.asset.list();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					total: assets.length,
+					assets
+				}, null, 2)
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err}`
+				}],
+				isError: true
+			};
+		}
+	});
+	server.registerTool("contentrain_register_asset", {
+		description: "Register a new asset in assets.json. The file must already exist at the specified path in the repository.",
+		inputSchema: {
+			path: z.string().describe("Relative path to the asset file (e.g., \"contentrain/static/hero.png\")"),
+			mimetype: z.string().describe("MIME type (e.g., \"image/png\", \"image/jpeg\", \"application/pdf\")"),
+			alt: z.string().optional().describe("Alt text for the asset")
+		}
+	}, async (params) => {
+		try {
+			const result = await writer.transaction(async (tx) => {
+				return tx.asset.register({
+					path: params.path,
+					mimetype: params.mimetype,
+					alt: params.alt
+				});
+			}, { message: `register asset: ${params.path}` });
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					asset: result
+				}, null, 2)
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err}`
+				}],
+				isError: true
+			};
+		}
+	});
+	server.registerTool("contentrain_deregister_asset", {
+		description: "Remove an asset from assets.json registry. Does NOT delete the physical file.",
+		annotations: { destructiveHint: true },
+		inputSchema: { path: z.string().describe("Asset path to deregister") }
+	}, async ({ path }) => {
+		try {
+			await writer.transaction(async (tx) => {
+				await tx.asset.deregister(path);
+			}, { message: `deregister asset: ${path}` });
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					deregistered: path
+				})
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err}`
+				}],
+				isError: true
+			};
+		}
+	});
+}
+//#endregion
+//#region src/server.ts
+function createServer(config) {
+	const server = new McpServer({
+		name: "contentrain",
+		version: "0.1.0"
+	});
+	const writer = new ContentrainWriter(config);
+	registerModelTools(server, writer);
+	registerContentTools(server, writer);
+	registerAssetTools(server, writer);
+	return server;
+}
+//#endregion
+//#region src/index.ts
+const repoPath = process.env.CONTENTRAIN_REPO_PATH || process.cwd();
+const branch = process.env.CONTENTRAIN_BRANCH || "contentrain";
+const remote = process.env.CONTENTRAIN_REMOTE || "origin";
+const contentrainDir = process.env.CONTENTRAIN_DIR || "contentrain";
+const dryRun = process.env.CONTENTRAIN_DRY_RUN === "true";
+const authorName = process.env.CONTENTRAIN_AUTHOR_NAME;
+const authorEmail = process.env.CONTENTRAIN_AUTHOR_EMAIL;
+const server = createServer({
+	repoPath,
+	branch,
+	remote,
+	contentrainDir,
+	dryRun,
+	author: authorName && authorEmail ? {
+		name: authorName,
+		email: authorEmail
+	} : void 0
+});
+async function main() {
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+}
+main().catch((err) => {
+	console.error("Failed to start Contentrain MCP server:", err);
+	process.exit(1);
+});
+//#endregion
+export { ContentrainWriter, createServer };
+
+//# sourceMappingURL=index.mjs.map