@contentrain/mcp 0.3.1 → 1.0.3

package/dist/index.mjs

@@ -1,2167 +1,21 @@
 #!/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 "./model-manager-sfPdrVIJ.mjs";
+import "./context-CRBCTYPB.mjs";
+import "./branch-lifecycle-DB6sgeJi.mjs";
+import { t as createServer } from "./server-CC12z_xq.mjs";
+import "./transaction-DXkMulzr.mjs";
+import "./validator-C3lZqO3U.mjs";
+import "./graph-builder-fPrDDwnu.mjs";
+import "./scanner-BdTiv8sw.mjs";
+import "./tsx-parser-CYVyBWjn.mjs";
+import "./apply-manager-BAeqrAHX.mjs";
+import { resolve } from "node:path";
 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]{8,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 8–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);
-		}
-	}
-	/**
-	* Run a staging transaction: worktree → execute → commit → push to staging branch → cleanup.
-	* Changes are pushed to a separate branch instead of the target branch.
-	*/
-	async stagingTransaction(fn, message, stagingBranch) {
-		const ctx = await this.createWorktree();
-		try {
-			const result = await fn(ctx.path);
-			const commitHash = await this.commit(ctx, message);
-			if (commitHash) {
-				const git = simpleGit(ctx.path);
-				try {
-					await git.push(this.config.remote, `${ctx.branch}:${stagingBranch}`);
-				} catch (err) {
-					throw new GitSyncError(`Failed to push to staging branch "${stagingBranch}"`, {
-						branch: stagingBranch,
-						originalError: String(err)
-					});
-				}
-			}
-			return {
-				result,
-				hasChanges: !!commitHash
-			};
-		} finally {
-			await this.cleanup(ctx);
-		}
-	}
-	/**
-	* Merge a remote staging branch into the target branch.
-	* Tries fast-forward first, falls back to merge commit.
-	*/
-	async mergeStagingToTarget(stagingBranch) {
-		const git = simpleGit(this.config.repoPath);
-		const remote = this.config.remote;
-		await git.fetch(remote, stagingBranch);
-		try {
-			await git.raw([
-				"rev-parse",
-				"--verify",
-				`${remote}/${stagingBranch}`
-			]);
-		} catch {
-			throw new GitSyncError(`Staging branch "${stagingBranch}" not found on remote "${remote}"`, { branch: stagingBranch });
-		}
-		await git.fetch(remote, this.config.branch);
-		const ctx = await this.createWorktree();
-		try {
-			const wtGit = simpleGit(ctx.path);
-			try {
-				await wtGit.merge([`${remote}/${stagingBranch}`, "--ff-only"]);
-			} catch {
-				await wtGit.merge([
-					`${remote}/${stagingBranch}`,
-					"-m",
-					`${this.config.commitPrefix} apply doctor fix from ${stagingBranch}`
-				]);
-			}
-			await this.pushWithRetry(ctx);
-			try {
-				await git.push(remote, `:${stagingBranch}`);
-			} catch {}
-			return (await wtGit.log({ maxCount: 1 })).latest?.hash || "";
-		} finally {
-			await this.cleanup(ctx);
-		}
-	}
-	/**
-	* Delete a remote staging branch without merging.
-	*/
-	async deleteStagingBranch(stagingBranch) {
-		const git = simpleGit(this.config.repoPath);
-		try {
-			await git.push(this.config.remote, `:${stagingBranch}`);
-		} catch (err) {
-			throw new GitSyncError(`Failed to delete staging branch "${stagingBranch}"`, {
-				branch: stagingBranch,
-				originalError: String(err)
-			});
-		}
-	}
-	/**
-	* 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");
-	}
-	/**
-	* Execute operations and push to a staging branch instead of the target branch.
-	* Returns the result and whether any changes were pushed.
-	*/
-	async stagingTransaction(fn, options) {
-		if (this.config.dryRun) return {
-			result: await this.dryRunTransaction(fn),
-			hasChanges: false
-		};
-		return this.gitSync.stagingTransaction(async (worktreePath) => {
-			return fn(this.createManagers(worktreePath));
-		}, options.message, options.stagingBranch);
-	}
-	/**
-	* Merge a staging branch into the target branch.
-	*/
-	async applyStagingBranch(stagingBranch) {
-		return this.gitSync.mergeStagingToTarget(stagingBranch);
-	}
-	/**
-	* Delete a staging branch without merging.
-	*/
-	async discardStagingBranch(stagingBranch) {
-		return this.gitSync.deleteStagingBranch(stagingBranch);
-	}
-	/**
-	* 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 {
-			basePath,
-			repoPath,
-			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/core/doctor.ts
-var Doctor = class {
-	issues = [];
-	fixed = 0;
-	totalEntries = 0;
-	scannedEntries = 0;
-	idRemap = /* @__PURE__ */ new Map();
-	contentFiles = [];
-	fieldsByModel = /* @__PURE__ */ new Map();
-	constructor(basePath, repoPath) {
-		this.basePath = basePath;
-		this.repoPath = repoPath;
-	}
-	async diagnose(options = {}) {
-		this.issues = [];
-		this.fixed = 0;
-		this.totalEntries = 0;
-		this.scannedEntries = 0;
-		this.idRemap = /* @__PURE__ */ new Map();
-		this.contentFiles = [];
-		this.fieldsByModel = /* @__PURE__ */ new Map();
-		const fix = options.fix ?? false;
-		const models = await this.checkMetadata();
-		if (!models) return this.buildResult(0);
-		const targetModels = options.modelId ? models.filter((m) => m.modelId === options.modelId) : models;
-		if (options.modelId && targetModels.length === 0) {
-			this.addIssue("error", "structure", `Model "${options.modelId}" not found in metadata.json`);
-			return this.buildResult(models.length);
-		}
-		await this.checkFieldFiles(models, targetModels);
-		const assets = await this.loadAssets();
-		await this.loadAllContentFiles(fix ? models : targetModels);
-		for (const model of models) try {
-			const fields = await readJsonFile(join(this.basePath, "models", `${model.modelId}.json`));
-			this.fieldsByModel.set(model.modelId, fields);
-		} catch {}
-		for (const cf of this.contentFiles) if (targetModels.some((m) => m.modelId === cf.modelId)) this.scannedEntries += cf.entries.length;
-		for (const model of targetModels) {
-			this.checkModelStructure(model);
-			this.checkModelContent(model, assets, fix);
-			if (model.type === "MD" || model.type === "MDX") {
-				const modelFiles = this.contentFiles.filter((f) => f.modelId === model.modelId);
-				await this.checkMarkdownSync(model, modelFiles);
-			}
-		}
-		if (!options.modelId) await this.checkOrphanDirectories(models);
-		if (fix && this.idRemap.size > 0) this.propagateIdChanges();
-		if (fix) await this.writeDirtyFiles();
-		return this.buildResult(targetModels.length);
-	}
-	async loadAllContentFiles(models) {
-		for (const model of models) {
-			const contentDir = join(this.basePath, model.modelId);
-			const fileNames = await listJsonFiles(contentDir);
-			for (const fileName of fileNames) {
-				const filePath = join(contentDir, `${fileName}.json`);
-				let entries;
-				try {
-					const raw = await readFile(filePath, "utf-8");
-					entries = JSON.parse(raw);
-					if (!Array.isArray(entries)) {
-						this.addIssue("error", "structure", "Content file is not an array", model.modelId, void 0, void 0, `${model.modelId}/${fileName}.json`);
-						continue;
-					}
-				} catch {
-					this.addIssue("error", "structure", "Invalid JSON in content file", model.modelId, void 0, void 0, `${model.modelId}/${fileName}.json`);
-					continue;
-				}
-				this.totalEntries += entries.length;
-				this.contentFiles.push({
-					modelId: model.modelId,
-					fileName,
-					filePath,
-					entries,
-					dirty: false
-				});
-			}
-		}
-	}
-	async checkMetadata() {
-		const metadataPath = join(this.basePath, "models", "metadata.json");
-		try {
-			const raw = await readFile(metadataPath, "utf-8");
-			try {
-				const models = JSON.parse(raw);
-				if (!Array.isArray(models)) {
-					this.addIssue("error", "structure", "metadata.json is not an array", void 0, void 0, void 0, "models/metadata.json");
-					return null;
-				}
-				const seen = /* @__PURE__ */ new Map();
-				for (const m of models) {
-					const count = (seen.get(m.modelId) ?? 0) + 1;
-					seen.set(m.modelId, count);
-				}
-				for (const [modelId, count] of seen) if (count > 1) this.addIssue("error", "structure", `Duplicate modelId "${modelId}" in metadata.json (${count} times)`, modelId, void 0, void 0, "models/metadata.json");
-				return models;
-			} catch {
-				this.addIssue("error", "structure", "metadata.json contains invalid JSON", void 0, void 0, void 0, "models/metadata.json");
-				return null;
-			}
-		} catch {
-			this.addIssue("error", "structure", "metadata.json not found — is this a Contentrain project?", void 0, void 0, void 0, "models/metadata.json");
-			return null;
-		}
-	}
-	async checkFieldFiles(allModels, targetModels) {
-		for (const model of targetModels) if (!await fileExists(join(this.basePath, "models", `${model.modelId}.json`))) this.addIssue("error", "structure", `Field definition file missing for model "${model.modelId}"`, model.modelId, void 0, void 0, `models/${model.modelId}.json`);
-		const metaIds = new Set(allModels.map((m) => m.modelId));
-		const fieldFiles = await listJsonFiles(join(this.basePath, "models"));
-		for (const file of fieldFiles) {
-			if (file === "metadata") continue;
-			if (!metaIds.has(file)) this.addIssue("warning", "structure", `Field definition file "${file}.json" has no matching model in metadata.json`, file, void 0, void 0, `models/${file}.json`);
-		}
-	}
-	async checkOrphanDirectories(models) {
-		const modelIds = new Set(models.map((m) => m.modelId));
-		const { readdir, stat } = await import("node:fs/promises");
-		try {
-			const entries = await readdir(this.basePath);
-			for (const entry of entries) {
-				if (entry === "models" || entry === "assets.json" || entry === "static" || entry.startsWith(".")) continue;
-				if ((await stat(join(this.basePath, entry))).isDirectory() && !modelIds.has(entry)) this.addIssue("warning", "structure", `Content directory "${entry}/" has no matching model in metadata.json`, entry);
-			}
-		} catch {}
-	}
-	checkModelStructure(model) {
-		const fields = this.fieldsByModel.get(model.modelId);
-		if (!fields) return;
-		for (const sysId of [
-			"createdAt",
-			"updatedAt",
-			"ID",
-			"status"
-		]) if (!fields.some((f) => f.fieldId === sysId && f.system)) this.addIssue("error", "schema", `Missing system field "${sysId}" in field definitions`, model.modelId, void 0, void 0, `models/${model.modelId}.json`);
-		if (model.type === "MD" || model.type === "MDX") {
-			if (!fields.some((f) => f.fieldId === "slug")) this.addIssue("error", "schema", "MD/MDX model missing required \"slug\" field", model.modelId, void 0, void 0, `models/${model.modelId}.json`);
-			if (!fields.some((f) => f.fieldId === "content")) this.addIssue("warning", "schema", "MD/MDX model missing \"content\" field definition", model.modelId, void 0, void 0, `models/${model.modelId}.json`);
-		}
-	}
-	checkModelContent(model, assets, fix) {
-		const fields = this.fieldsByModel.get(model.modelId);
-		if (!fields) return;
-		const modelFiles = this.contentFiles.filter((f) => f.modelId === model.modelId);
-		if (modelFiles.length === 0 && !model.localization) {
-			this.addIssue("warning", "structure", `No content files found for model "${model.modelId}"`, model.modelId);
-			return;
-		}
-		for (const cf of modelFiles) {
-			const fileIdSet = /* @__PURE__ */ new Map();
-			for (const entry of cf.entries) {
-				const count = (fileIdSet.get(entry.ID) ?? 0) + 1;
-				fileIdSet.set(entry.ID, count);
-			}
-			for (const [id, count] of fileIdSet) if (count > 1) {
-				this.addIssue("error", "id", `Duplicate ID "${id}" appears ${count} times in same file`, model.modelId, id, void 0, `${model.modelId}/${cf.fileName}.json`, fix ? "Will regenerate duplicate IDs and update relations" : void 0);
-				if (fix) this.fixDuplicateIds(cf, id);
-			}
-			for (const entry of cf.entries) this.checkEntry(model, fields, entry, assets, `${model.modelId}/${cf.fileName}.json`, fix, cf);
-			this.checkUniqueConstraints(model, fields, cf.entries, `${model.modelId}/${cf.fileName}.json`);
-		}
-		if (model.localization && modelFiles.length > 1) this.checkLocaleIdConsistency(model, modelFiles);
-	}
-	checkEntry(model, fields, entry, assets, file, fix, cf) {
-		const entryId = entry.ID;
-		if (!entryId || typeof entryId !== "string") {
-			this.addIssue("error", "id", "Entry missing ID field", model.modelId, void 0, "ID", file);
-			return;
-		}
-		if (!isValidId(entryId)) {
-			const existingNewId = this.idRemap.get(entryId);
-			const newId = fix ? existingNewId || generateId() : void 0;
-			this.addIssue("error", "id", `Invalid ID format "${entryId}" — must be 12-char lowercase hex`, model.modelId, entryId, "ID", file, fix ? `Regenerated to "${newId}" and updating all relations` : void 0);
-			if (fix && newId) {
-				this.idRemap.set(entryId, newId);
-				entry.ID = newId;
-				cf.dirty = true;
-				if (!existingNewId) this.fixed++;
-			}
-		}
-		if (!entry.createdAt) {
-			this.addIssue("error", "schema", "Missing createdAt", model.modelId, entryId, "createdAt", file, fix ? "Will set to current timestamp" : void 0);
-			if (fix) {
-				entry.createdAt = (/* @__PURE__ */ new Date()).toISOString();
-				cf.dirty = true;
-				this.fixed++;
-			}
-		}
-		if (!entry.updatedAt) {
-			this.addIssue("error", "schema", "Missing updatedAt", model.modelId, entryId, "updatedAt", file, fix ? "Will set to current timestamp" : void 0);
-			if (fix) {
-				entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-				cf.dirty = true;
-				this.fixed++;
-			}
-		}
-		if (!entry.status) {
-			this.addIssue("error", "schema", "Missing status", model.modelId, entryId, "status", file, fix ? "Will set to \"draft\"" : void 0);
-			if (fix) {
-				entry.status = "draft";
-				cf.dirty = true;
-				this.fixed++;
-			}
-		} else if (![
-			"draft",
-			"publish",
-			"changed"
-		].includes(entry.status)) {
-			this.addIssue("error", "schema", `Invalid status "${entry.status}" — must be draft, publish, or changed`, model.modelId, entryId, "status", file, fix ? "Will set to \"draft\"" : void 0);
-			if (fix) {
-				entry.status = "draft";
-				cf.dirty = true;
-				this.fixed++;
-			}
-		}
-		if (entry.createdAt && isNaN(Date.parse(entry.createdAt))) this.addIssue("error", "schema", `Invalid createdAt date format "${entry.createdAt}"`, model.modelId, entryId, "createdAt", file);
-		if (entry.updatedAt && isNaN(Date.parse(entry.updatedAt))) this.addIssue("error", "schema", `Invalid updatedAt date format "${entry.updatedAt}"`, model.modelId, entryId, "updatedAt", file);
-		const nonSystemFields = fields.filter((f) => !f.system);
-		for (const field of nonSystemFields) {
-			const value = entry[field.fieldId];
-			if (field.validations?.["required-field"]?.value) {
-				if (value === void 0 || value === null || value === "") {
-					if (field.fieldId === "content" && (model.type === "MD" || model.type === "MDX")) continue;
-					this.addIssue("error", "schema", `Required field "${field.fieldId}" is empty`, model.modelId, entryId, field.fieldId, file);
-					continue;
-				}
-			}
-			if (value === void 0 || value === null) continue;
-			const typeError = validateFieldValue(value, getExpectedType(field.componentId, field.fieldType), field.fieldId);
-			if (typeError) {
-				this.addIssue("error", "schema", `Type mismatch: ${typeError}`, model.modelId, entryId, field.fieldId, file);
-				continue;
-			}
-			if (field.componentId === "integer") {
-				const intError = validateInteger(value, field.fieldId);
-				if (intError) this.addIssue("error", "schema", intError, model.modelId, entryId, field.fieldId, file);
-			}
-			if (field.componentId === "one-to-one" && typeof value === "string") this.checkRelation(model.modelId, entryId, field, value, file);
-			if (field.componentId === "one-to-many" && Array.isArray(value)) for (const refId of value) if (typeof refId === "string") this.checkRelation(model.modelId, entryId, field, refId, file);
-			else this.addIssue("error", "relation", "one-to-many array contains non-string value", model.modelId, entryId, field.fieldId, file);
-			if ((field.componentId === "one-to-one" || field.componentId === "one-to-many") && !field.options?.reference?.form?.reference?.value) this.addIssue("warning", "relation", `Relation field "${field.fieldId}" missing options.reference.form.reference.value`, model.modelId, void 0, field.fieldId, `models/${model.modelId}.json`);
-			if (field.componentId === "media" && typeof value === "string" && value !== "") {
-				if (!assets.some((a) => a.path === value)) this.addIssue("error", "asset", `Media path "${value}" not found in assets.json`, model.modelId, entryId, field.fieldId, file);
-			}
-		}
-	}
-	checkRelation(modelId, entryId, field, refId, file) {
-		const refModelId = field.options?.reference?.form?.reference?.value;
-		if (!refModelId) return;
-		if (!isValidId(refId)) {
-			this.addIssue("error", "relation", `Relation references invalid ID "${refId}"`, modelId, entryId, field.fieldId, file);
-			return;
-		}
-		if (!this.contentFiles.filter((f) => f.modelId === refModelId).some((rf) => rf.entries.some((e) => e.ID === refId))) this.addIssue("error", "relation", `Referenced entry "${refId}" not found in model "${refModelId}"`, modelId, entryId, field.fieldId, file);
-	}
-	checkUniqueConstraints(model, fields, entries, file) {
-		const uniqueFields = fields.filter((f) => f.validations?.["unique-field"]?.value && !f.system);
-		for (const field of uniqueFields) {
-			const seen = /* @__PURE__ */ new Map();
-			for (const entry of entries) {
-				const value = entry[field.fieldId];
-				if (value === void 0 || value === null || value === "") continue;
-				const key = typeof value === "object" ? JSON.stringify(value) : value;
-				const existing = seen.get(key);
-				if (existing) this.addIssue("error", "schema", `Unique constraint violated: "${field.fieldId}" value "${value}" duplicated between entries ${existing} and ${entry.ID}`, model.modelId, entry.ID, field.fieldId, file);
-				else seen.set(key, entry.ID);
-			}
-		}
-	}
-	checkLocaleIdConsistency(model, modelFiles) {
-		if (modelFiles.length < 2) return;
-		const referenceFile = modelFiles[0];
-		const referenceIds = new Set(referenceFile.entries.map((e) => e.ID));
-		for (let i = 1; i < modelFiles.length; i++) {
-			const otherFile = modelFiles[i];
-			const otherIds = new Set(otherFile.entries.map((e) => e.ID));
-			for (const id of referenceIds) if (!otherIds.has(id)) this.addIssue("error", "id", `Entry "${id}" exists in ${referenceFile.fileName}.json but missing in ${otherFile.fileName}.json`, model.modelId, id, void 0, `${model.modelId}/${otherFile.fileName}.json`);
-			for (const id of otherIds) if (!referenceIds.has(id)) this.addIssue("error", "id", `Entry "${id}" exists in ${otherFile.fileName}.json but missing in ${referenceFile.fileName}.json`, model.modelId, id, void 0, `${model.modelId}/${referenceFile.fileName}.json`);
-		}
-	}
-	async checkMarkdownSync(model, modelFiles) {
-		for (const cf of modelFiles) {
-			const locale = model.localization && cf.fileName !== model.modelId ? cf.fileName : void 0;
-			for (const entry of cf.entries) {
-				if (!("slug" in entry) || !entry.slug) {
-					this.addIssue("error", "sync", "MD/MDX entry missing \"slug\" field", model.modelId, entry.ID, "slug", `${model.modelId}/${cf.fileName}.json`);
-					continue;
-				}
-				const mdEntry = entry;
-				const ext = model.type === "MDX" ? ".mdx" : ".md";
-				const baseMdPath = mdEntry.path || model.path || "";
-				const mdPath = locale ? join(this.repoPath, baseMdPath, locale, `${mdEntry.slug}${ext}`) : join(this.repoPath, baseMdPath, `${mdEntry.slug}${ext}`);
-				if (!await fileExists(mdPath)) this.addIssue("error", "sync", `Markdown file missing for entry "${mdEntry.slug}"`, model.modelId, entry.ID, void 0, mdPath.replace(this.repoPath + "/", ""));
-				if ("content" in entry && entry.content && typeof entry.content === "string" && entry.content.length > 0) this.addIssue("warning", "sync", "MD/MDX JSON index should not contain \"content\" body — body belongs in markdown file", model.modelId, entry.ID, "content", `${model.modelId}/${cf.fileName}.json`);
-			}
-		}
-	}
-	async loadAssets() {
-		try {
-			return await readJsonFile(join(this.basePath, "assets.json"));
-		} catch {
-			this.addIssue("warning", "structure", "assets.json not found or invalid");
-			return [];
-		}
-	}
-	/**
-	* After all ID fixes are collected in idRemap, propagate changes
-	* to ALL relation fields across ALL loaded content files.
-	*
-	* This is the critical two-way binding: when entry A's ID changes,
-	* every relation field in every model that points to A must be updated.
-	*/
-	propagateIdChanges() {
-		if (this.idRemap.size === 0) return;
-		for (const cf of this.contentFiles) {
-			const fields = this.fieldsByModel.get(cf.modelId);
-			if (!fields) continue;
-			const relationFields = fields.filter((f) => f.componentId === "one-to-one" || f.componentId === "one-to-many");
-			if (relationFields.length === 0) continue;
-			for (const entry of cf.entries) for (const field of relationFields) {
-				const value = entry[field.fieldId];
-				if (value === void 0 || value === null) continue;
-				if (field.componentId === "one-to-one" && typeof value === "string") {
-					const newId = this.idRemap.get(value);
-					if (newId) {
-						this.addIssue("warning", "relation", `Updated relation "${field.fieldId}": "${value}" → "${newId}"`, cf.modelId, entry.ID, field.fieldId, `${cf.modelId}/${cf.fileName}.json`, "Propagated ID change to relation");
-						entry[field.fieldId] = newId;
-						cf.dirty = true;
-						this.fixed++;
-					}
-				}
-				if (field.componentId === "one-to-many" && Array.isArray(value)) {
-					let changed = false;
-					const updated = value.map((refId) => {
-						const newId = this.idRemap.get(refId);
-						if (newId) {
-							changed = true;
-							return newId;
-						}
-						return refId;
-					});
-					if (changed) {
-						this.addIssue("warning", "relation", `Updated one-to-many relation "${field.fieldId}": propagated ${this.idRemap.size} ID change(s)`, cf.modelId, entry.ID, field.fieldId, `${cf.modelId}/${cf.fileName}.json`, "Propagated ID changes to relation array");
-						entry[field.fieldId] = updated;
-						cf.dirty = true;
-						this.fixed++;
-					}
-				}
-			}
-		}
-	}
-	fixDuplicateIds(cf, duplicateId) {
-		let first = true;
-		for (const entry of cf.entries) if (entry.ID === duplicateId) {
-			if (first) {
-				first = false;
-				continue;
-			}
-			const newId = generateId();
-			this.idRemap.set(`${duplicateId}:dup:${newId}`, newId);
-			entry.ID = newId;
-			cf.dirty = true;
-			this.fixed++;
-		}
-	}
-	async writeDirtyFiles() {
-		for (const cf of this.contentFiles) if (cf.dirty) await writeJsonFile(cf.filePath, cf.entries);
-	}
-	addIssue(severity, category, message, modelId, entryId, field, file, fix) {
-		this.issues.push({
-			severity,
-			category,
-			modelId,
-			entryId,
-			field,
-			file,
-			message,
-			fix
-		});
-	}
-	buildResult(modelCount) {
-		const unfixedErrors = this.issues.filter((i) => i.severity === "error" && !i.fix).length;
-		return {
-			summary: {
-				total: this.issues.length,
-				errors: unfixedErrors,
-				warnings: this.issues.filter((i) => i.severity === "warning").length,
-				fixed: this.fixed,
-				models: modelCount,
-				entries: this.scannedEntries
-			},
-			issues: this.issues
-		};
-	}
-};
-//#endregion
-//#region src/tools/doctor.ts
-function registerDoctorTools(server, writer, config) {
-	const targetBranch = config.branch || "contentrain";
-	const stagingPrefix = `${targetBranch}--doctor-fix/`;
-	function isStagingBranch(branch) {
-		return branch.startsWith(stagingPrefix);
-	}
-	server.registerTool("contentrain_doctor", {
-		description: [
-			"Run a full diagnostic scan on all Contentrain models, content, and assets.",
-			"Detects: duplicate/invalid IDs, type mismatches, broken relations, missing assets,",
-			"locale ID inconsistencies, orphan directories, MD/MDX sync issues, unique constraint",
-			"violations, missing system fields, and invalid JSON files.",
-			"Use fix=true to auto-repair fixable issues — changes are pushed to a staging branch",
-			"for review. Use contentrain_doctor_apply to merge the staging branch into the target.",
-			"Use modelId to scope the scan to a single model."
-		].join(" "),
-		annotations: { readOnlyHint: false },
-		inputSchema: {
-			fix: z.boolean().optional().default(false).describe("Auto-fix repairable issues (duplicate IDs, missing timestamps, invalid status). Pushes to a staging branch for review."),
-			modelId: z.string().optional().describe("Scope scan to a specific model ID. Omit to scan all models.")
-		}
-	}, async ({ fix, modelId }) => {
-		try {
-			if (fix) {
-				const stagingBranch = `${stagingPrefix}${Date.now()}`;
-				const { result, hasChanges } = await writer.stagingTransaction(async (tx) => {
-					return new Doctor(tx.basePath, tx.repoPath).diagnose({
-						fix: true,
-						modelId
-					});
-				}, {
-					message: `doctor fix${modelId ? ` ${modelId}` : ""}`,
-					stagingBranch
-				});
-				return { content: [{
-					type: "text",
-					text: formatResult(result, hasChanges ? stagingBranch : void 0)
-				}] };
-			}
-			const contentrainDir = config.contentrainDir || "contentrain";
-			return { content: [{
-				type: "text",
-				text: formatResult(await new Doctor(join(config.repoPath, contentrainDir), config.repoPath).diagnose({
-					fix: false,
-					modelId
-				}))
-			}] };
-		} catch (err) {
-			return {
-				content: [{
-					type: "text",
-					text: `Error: ${err}`
-				}],
-				isError: true
-			};
-		}
-	});
-	server.registerTool("contentrain_doctor_apply", {
-		description: [
-			"Apply a staged doctor fix by merging the staging branch into the target branch.",
-			"Use the stagingBranch value returned by contentrain_doctor fix=true.",
-			"Attempts fast-forward merge first, falls back to merge commit.",
-			"Deletes the staging branch after successful merge."
-		].join(" "),
-		annotations: { readOnlyHint: false },
-		inputSchema: { branch: z.string().describe(`The staging branch name returned by contentrain_doctor fix=true (e.g., "${stagingPrefix}1234567890")`) }
-	}, async ({ branch }) => {
-		try {
-			if (!isStagingBranch(branch)) return {
-				content: [{
-					type: "text",
-					text: `Error: branch must start with "${stagingPrefix}" — only doctor staging branches for the "${targetBranch}" target can be applied.`
-				}],
-				isError: true
-			};
-			return { content: [{
-				type: "text",
-				text: `✅ Doctor fix applied to "${targetBranch}".\nCommit: ${await writer.applyStagingBranch(branch)}\nStaging branch "${branch}" has been deleted.`
-			}] };
-		} catch (err) {
-			return {
-				content: [{
-					type: "text",
-					text: `Error: ${err}`
-				}],
-				isError: true
-			};
-		}
-	});
-	server.registerTool("contentrain_doctor_discard", {
-		description: "Discard a staged doctor fix by deleting the staging branch without merging.",
-		annotations: { readOnlyHint: false },
-		inputSchema: { branch: z.string().describe(`The staging branch name to discard (e.g., "${stagingPrefix}1234567890")`) }
-	}, async ({ branch }) => {
-		try {
-			if (!isStagingBranch(branch)) return {
-				content: [{
-					type: "text",
-					text: `Error: branch must start with "${stagingPrefix}" — only doctor staging branches can be discarded.`
-				}],
-				isError: true
-			};
-			await writer.discardStagingBranch(branch);
-			return { content: [{
-				type: "text",
-				text: `Staging branch "${branch}" has been deleted.`
-			}] };
-		} catch (err) {
-			return {
-				content: [{
-					type: "text",
-					text: `Error: ${err}`
-				}],
-				isError: true
-			};
-		}
-	});
-}
-function formatResult(result, stagingBranch) {
-	const { summary, issues } = result;
-	const lines = [];
-	if (summary.errors === 0 && summary.warnings === 0 && summary.fixed === 0) lines.push("✅ No issues found!");
-	else if (summary.errors === 0 && summary.fixed > 0) lines.push("✅ All fixable issues have been repaired.");
-	else if (summary.errors === 0) lines.push("⚠️ No errors, but some warnings found.");
-	else lines.push("❌ Issues detected.");
-	lines.push("");
-	lines.push(`Models scanned: ${summary.models}`);
-	lines.push(`Entries scanned: ${summary.entries}`);
-	lines.push(`Errors: ${summary.errors}`);
-	lines.push(`Warnings: ${summary.warnings}`);
-	if (summary.fixed > 0) lines.push(`Fixed: ${summary.fixed}`);
-	if (stagingBranch) {
-		lines.push("");
-		lines.push(`📦 Staging branch: ${stagingBranch}`);
-		lines.push("→ Review the changes, then run contentrain_doctor_apply to merge into the target branch.");
-		lines.push("→ Or run contentrain_doctor_discard to discard without applying.");
-	}
-	if (issues.length > 0) {
-		lines.push("");
-		const grouped = /* @__PURE__ */ new Map();
-		for (const issue of issues) {
-			const key = issue.category;
-			const arr = grouped.get(key) ?? [];
-			arr.push(issue);
-			grouped.set(key, arr);
-		}
-		const categoryLabels = {
-			structure: "📁 Structure",
-			id: "🔑 IDs",
-			schema: "📋 Schema",
-			relation: "🔗 Relations",
-			asset: "🖼️ Assets",
-			sync: "📝 MD/MDX Sync"
-		};
-		for (const [category, categoryIssues] of grouped) {
-			lines.push(`\n### ${categoryLabels[category] || category}`);
-			for (const issue of categoryIssues) {
-				const icon = issue.fix ? "✅" : issue.severity === "error" ? "❌" : "⚠️";
-				const location = [
-					issue.modelId,
-					issue.entryId,
-					issue.field
-				].filter(Boolean).join(" → ");
-				const filePart = issue.file ? ` (${issue.file})` : "";
-				const fixPart = issue.fix ? ` [FIX: ${issue.fix}]` : "";
-				lines.push(`  ${icon} ${location ? `[${location}]` : ""}${filePart} ${issue.message}${fixPart}`);
-			}
-		}
-	}
-	lines.push("\n---\n");
-	lines.push(JSON.stringify(result, null, 2));
-	return lines.join("\n");
-}
-//#endregion
-//#region src/server.ts
-function createServer(config) {
-	const server = new McpServer({
-		name: "contentrain",
-		version: "0.1.1"
-	});
-	const writer = new ContentrainWriter(config);
-	registerModelTools(server, writer);
-	registerContentTools(server, writer);
-	registerAssetTools(server, writer);
-	registerDoctorTools(server, writer, config);
-	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);
-});
+const server = createServer(resolve(process.env["CONTENTRAIN_PROJECT_ROOT"] ?? process.cwd()));
+const transport = new StdioServerTransport();
+await server.connect(transport);
 //#endregion
-export { ContentrainWriter, Doctor, createServer };
+export {};
 
 //# sourceMappingURL=index.mjs.map