@contentrain/mcp 0.3.1 → 1.0.3

package/dist/model-manager-sfPdrVIJ.mjs

@@ -0,0 +1,1016 @@
+import { a as readJson, c as writeText, i as readDir, n as ensureDir, o as readText, s as writeJson, t as contentrainDir } from "./fs-BbuGnVcG.mjs";
+import { n as generateEntryId } from "./id-BdD4HvMY.mjs";
+import { r as writeMeta, t as deleteMeta } from "./meta-manager-CECrfsKm.mjs";
+import { join } from "node:path";
+import { z } from "zod";
+import { rm } from "node:fs/promises";
+//#region src/core/content-manager.ts
+const SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const ENTRY_ID_RE = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,39}$/;
+const LOCALE_RE = /^[a-z]{2}(?:-[A-Z]{2})?$/;
+function validateSlug(slug) {
+	if (!slug) return "Slug is required";
+	if (!SLUG_RE.test(slug)) return `Invalid slug "${slug}": must be kebab-case alphanumeric (a-z, 0-9, hyphens)`;
+	if (slug.startsWith(".") || slug.includes("..")) return `Invalid slug "${slug}": path traversal not allowed`;
+	return null;
+}
+function validateEntryId(id) {
+	if (!ENTRY_ID_RE.test(id)) return `Invalid entry ID "${id}": must be 1-40 alphanumeric characters (hyphens and underscores allowed)`;
+	return null;
+}
+function validateLocale(locale, config) {
+	if (!LOCALE_RE.test(locale)) return `Invalid locale "${locale}": must be ISO 639-1 format (e.g. "en", "tr", "pt-BR")`;
+	if (!config.locales.supported.includes(locale)) return `Locale "${locale}" is not in supported locales [${config.locales.supported.join(", ")}]. Update config first.`;
+	return null;
+}
+function parseFrontmatter(content) {
+	const normalized = content.replace(/\r\n/g, "\n");
+	const match = normalized.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+	if (!match) return {
+		frontmatter: {},
+		body: normalized
+	};
+	const frontmatterStr = match[1];
+	const body = match[2].trim();
+	const frontmatter = {};
+	let currentKey = null;
+	let currentArray = null;
+	for (const line of frontmatterStr.split("\n")) {
+		if (/^\s+-\s+/.test(line) && currentKey) {
+			const value = line.replace(/^\s+-\s+/, "").trim();
+			if (!currentArray) currentArray = [];
+			currentArray.push(value);
+			continue;
+		}
+		if (currentKey && currentArray) {
+			frontmatter[currentKey] = currentArray;
+			currentKey = null;
+			currentArray = null;
+		}
+		const kvMatch = line.match(/^([\w][\w.-]*)\s*:\s*(.*)$/);
+		if (!kvMatch) continue;
+		const key = kvMatch[1];
+		const rawValue = kvMatch[2].trim();
+		if (rawValue === "") {
+			currentKey = key;
+			currentArray = [];
+			continue;
+		}
+		if (rawValue.startsWith("[") && rawValue.endsWith("]")) {
+			frontmatter[key] = rawValue.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean);
+			continue;
+		}
+		frontmatter[key] = parseYamlValue(rawValue);
+	}
+	if (currentKey && currentArray) frontmatter[currentKey] = currentArray;
+	return {
+		frontmatter,
+		body
+	};
+}
+function parseYamlValue(raw) {
+	if (raw === "true") return true;
+	if (raw === "false") return false;
+	if (raw === "null") return null;
+	if (/^-?\d+$/.test(raw)) return parseInt(raw, 10);
+	if (/^-?\d+\.\d+$/.test(raw)) return parseFloat(raw);
+	if (raw.startsWith("\"") && raw.endsWith("\"") || raw.startsWith("'") && raw.endsWith("'")) return raw.slice(1, -1);
+	return raw;
+}
+function yamlScalar(value) {
+	const str = String(value);
+	if (str.includes(":") || str.includes("#") || str.includes("{") || str.includes("}") || str.includes("[") || str.includes("]") || str.includes("*") || str.includes("&") || str.includes("!") || str.includes("|") || str.includes(">") || str.includes("'") || str.includes("\"") || str.includes("%") || str.includes("@") || str.includes("`") || str.startsWith("-") || str.startsWith("?") || str === "true" || str === "false" || str === "null" || str === "yes" || str === "no" || str === "") return `"${str.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+	return str;
+}
+function serializeYamlValue(value, indent) {
+	const pad = "  ".repeat(indent);
+	if (value === null || value === void 0) return [];
+	if (typeof value === "object" && !Array.isArray(value)) {
+		const lines = [];
+		for (const [k, v] of Object.entries(value)) {
+			if (v === null || v === void 0) continue;
+			if (typeof v === "object" && !Array.isArray(v)) {
+				lines.push(`${pad}${k}:`);
+				lines.push(...serializeYamlValue(v, indent + 1));
+			} else if (Array.isArray(v)) {
+				lines.push(`${pad}${k}:`);
+				for (const item of v) if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+					const nested = serializeYamlValue(item, indent + 2);
+					if (nested.length > 0) {
+						lines.push(`${pad}  - ${nested[0].trimStart()}`);
+						lines.push(...nested.slice(1));
+					}
+				} else lines.push(`${pad}  - ${yamlScalar(item)}`);
+			} else lines.push(`${pad}${k}: ${yamlScalar(v)}`);
+		}
+		return lines;
+	}
+	if (Array.isArray(value)) {
+		const lines = [];
+		for (const item of value) if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+			const nested = serializeYamlValue(item, indent + 1);
+			if (nested.length > 0) {
+				lines.push(`${pad}- ${nested[0].trimStart()}`);
+				lines.push(...nested.slice(1));
+			}
+		} else lines.push(`${pad}- ${yamlScalar(item)}`);
+		return lines;
+	}
+	return [`${pad}${yamlScalar(value)}`];
+}
+function serializeYamlFields(data) {
+	const lines = [];
+	for (const [key, value] of Object.entries(data)) {
+		if (key === "body") continue;
+		if (value === null || value === void 0) continue;
+		if (typeof value === "object" && !Array.isArray(value)) {
+			lines.push(`${key}:`);
+			lines.push(...serializeYamlValue(value, 1));
+		} else if (Array.isArray(value)) {
+			lines.push(`${key}:`);
+			for (const item of value) if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+				const nested = serializeYamlValue(item, 2);
+				if (nested.length > 0) {
+					lines.push(`  - ${nested[0].trimStart()}`);
+					lines.push(...nested.slice(1));
+				}
+			} else lines.push(`  - ${yamlScalar(item)}`);
+		} else lines.push(`${key}: ${yamlScalar(value)}`);
+	}
+	return lines;
+}
+function serializeFrontmatter(data, body) {
+	const trimmedBody = body.trimStart();
+	if (trimmedBody.startsWith("---")) {
+		const endIdx = trimmedBody.indexOf("---", 3);
+		if (endIdx > 0) {
+			const bodyFmContent = trimmedBody.slice(3, endIdx).trim();
+			const afterFm = trimmedBody.slice(endIdx + 3);
+			const lines = ["---"];
+			lines.push(...serializeYamlFields(data));
+			if (bodyFmContent) {
+				const modelKeys = new Set(Object.keys(data));
+				for (const line of bodyFmContent.split("\n")) {
+					if (line.length > 0 && line[0] !== " " && line[0] !== "-") {
+						const colonIdx = line.indexOf(":");
+						const lineKey = colonIdx > 0 ? line.slice(0, colonIdx).trim() : "";
+						if (lineKey && modelKeys.has(lineKey)) continue;
+					}
+					lines.push(line);
+				}
+			}
+			lines.push("---");
+			if (afterFm.trim()) lines.push(afterFm.trimStart());
+			lines.push("");
+			return lines.join("\n");
+		}
+	}
+	const lines = ["---"];
+	lines.push(...serializeYamlFields(data));
+	lines.push("---");
+	lines.push("");
+	if (body) {
+		lines.push(body);
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+function resolveContentDir(projectRoot, model) {
+	if (model.content_path) return join(projectRoot, model.content_path);
+	return join(contentrainDir(projectRoot), "content", model.domain, model.id);
+}
+function resolveLocaleStrategy(model) {
+	return model.locale_strategy ?? "file";
+}
+/** Build the file path for a JSON content file (singleton/collection/dictionary) */
+function resolveJsonFilePath(dir, model, locale) {
+	if (!model.i18n) return join(dir, "data.json");
+	switch (resolveLocaleStrategy(model)) {
+		case "suffix": return join(dir, `${model.id}.${locale}.json`);
+		case "directory": return join(dir, locale, `${model.id}.json`);
+		case "none": return join(dir, `${model.id}.json`);
+		default: return join(dir, `${locale}.json`);
+	}
+}
+/** Build the file path for a markdown document */
+function resolveMdFilePath(dir, model, locale, slug) {
+	if (!model.i18n) return join(dir, `${slug}.md`);
+	switch (resolveLocaleStrategy(model)) {
+		case "suffix": return join(dir, `${slug}.${locale}.md`);
+		case "directory": return join(dir, locale, `${slug}.md`);
+		case "none": return join(dir, `${slug}.md`);
+		default: return join(dir, slug, `${locale}.md`);
+	}
+}
+function defaultMeta(data) {
+	const meta = {
+		status: "draft",
+		source: "agent",
+		updated_by: "contentrain-mcp"
+	};
+	if (data?.["publish_at"] !== void 0) meta.publish_at = data["publish_at"];
+	if (data?.["expire_at"] !== void 0) meta.expire_at = data["expire_at"];
+	return meta;
+}
+async function writeContent(projectRoot, model, entries, config) {
+	const results = [];
+	const defaultLocale = config.locales.default;
+	for (const entry of entries) {
+		const locale = entry.locale ?? defaultLocale;
+		const localeErr = validateLocale(locale, config);
+		if (localeErr) throw new Error(localeErr);
+		if (entry.id) {
+			const idErr = validateEntryId(entry.id);
+			if (idErr) throw new Error(idErr);
+		}
+		if (entry.slug) {
+			const slugErr = validateSlug(entry.slug);
+			if (slugErr) throw new Error(slugErr);
+		}
+		switch (model.kind) {
+			case "singleton":
+				await writeJson(resolveJsonFilePath(resolveContentDir(projectRoot, model), model, locale), entry.data);
+				await writeMeta(projectRoot, model, { locale }, defaultMeta(entry.data));
+				results.push({
+					action: "updated",
+					locale
+				});
+				break;
+			case "collection": {
+				const isNew = !entry.id;
+				const id = entry.id ?? generateEntryId();
+				const filePath = resolveJsonFilePath(resolveContentDir(projectRoot, model), model, locale);
+				const existing = await readJson(filePath) ?? {};
+				const action = isNew || !(id in existing) ? "created" : "updated";
+				existing[id] = entry.data;
+				const sorted = {};
+				for (const key of Object.keys(existing).toSorted()) sorted[key] = existing[key];
+				await writeJson(filePath, sorted);
+				await writeMeta(projectRoot, model, {
+					locale,
+					entryId: id
+				}, defaultMeta(entry.data));
+				results.push({
+					action,
+					id,
+					locale
+				});
+				break;
+			}
+			case "document": {
+				const slug = entry.slug ?? entry.data["slug"];
+				if (!slug) throw new Error("Document entries require a slug");
+				const slugErr = validateSlug(slug);
+				if (slugErr) throw new Error(slugErr);
+				const bodyContent = entry.data["body"] ?? "";
+				const fmData = { ...entry.data };
+				delete fmData["body"];
+				if (!fmData["slug"]) fmData["slug"] = slug;
+				const docPath = resolveMdFilePath(resolveContentDir(projectRoot, model), model, locale, slug);
+				const action = await readText(docPath) ? "updated" : "created";
+				await writeText(docPath, serializeFrontmatter(fmData, bodyContent));
+				await writeMeta(projectRoot, model, {
+					locale,
+					slug
+				}, defaultMeta(entry.data));
+				results.push({
+					action,
+					slug,
+					locale
+				});
+				break;
+			}
+			case "dictionary": {
+				const filePath = resolveJsonFilePath(resolveContentDir(projectRoot, model), model, locale);
+				const existing = await readJson(filePath) ?? {};
+				const collisions = [];
+				for (const key of Object.keys(entry.data)) if (key in existing && existing[key] !== entry.data[key]) collisions.push(key);
+				if (collisions.length > 0) throw new Error(`Dictionary "${model.id}" (${locale}): ${collisions.length} key collision(s) — [${collisions.join(", ")}] already exist with different values. Read existing keys with contentrain_content_list first, or include all keys in a single save call.`);
+				await writeJson(filePath, {
+					...existing,
+					...entry.data
+				});
+				await writeMeta(projectRoot, model, { locale }, defaultMeta(entry.data));
+				results.push({
+					action: "updated",
+					locale
+				});
+				break;
+			}
+		}
+	}
+	return results;
+}
+async function deleteContent(projectRoot, model, opts) {
+	const removed = [];
+	const cDir = resolveContentDir(projectRoot, model);
+	switch (model.kind) {
+		case "collection": {
+			if (!opts.id) throw new Error("Collection delete requires an entry ID");
+			const locales = opts.locale ? [opts.locale] : (await readDir(cDir)).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", "").replace(`${model.id}.`, ""));
+			for (const loc of locales) {
+				const filePath = resolveJsonFilePath(cDir, model, loc);
+				const data = await readJson(filePath);
+				if (data && opts.id in data) {
+					delete data[opts.id];
+					await writeJson(filePath, data);
+					removed.push(`content/${model.domain}/${model.id}/${loc}.json#${opts.id}`);
+				}
+			}
+			for (const loc of locales) await deleteMeta(projectRoot, model, {
+				locale: loc,
+				entryId: opts.id
+			});
+			break;
+		}
+		case "document": {
+			if (!opts.slug) throw new Error("Document delete requires a slug");
+			const slugDelErr = validateSlug(opts.slug);
+			if (slugDelErr) throw new Error(slugDelErr);
+			const strategy = resolveLocaleStrategy(model);
+			if (!model.i18n) await rm(join(cDir, `${opts.slug}.md`), { force: true });
+			else if (strategy === "file") await rm(join(cDir, opts.slug), {
+				recursive: true,
+				force: true
+			});
+			else if (opts.locale) await rm(resolveMdFilePath(cDir, model, opts.locale, opts.slug), { force: true });
+			else {
+				const files = await readDir(strategy === "directory" ? cDir : cDir);
+				for (const f of files) if (strategy === "suffix" && f.startsWith(`${opts.slug}.`) && f.endsWith(".md")) await rm(join(cDir, f), { force: true });
+				else if (strategy === "directory") await rm(join(cDir, f, `${opts.slug}.md`), { force: true });
+				else if (strategy === "none") {
+					if (f === `${opts.slug}.md`) await rm(join(cDir, f), { force: true });
+				}
+			}
+			removed.push(`${model.content_path ?? `content/${model.domain}/${model.id}`}/${opts.slug}`);
+			await deleteMeta(projectRoot, model, {
+				slug: opts.slug,
+				locale: opts.locale
+			});
+			break;
+		}
+		case "singleton": {
+			if (model.i18n && !opts.locale) throw new Error("Singleton delete requires a locale when i18n is enabled");
+			const locale = opts.locale ?? "data";
+			await rm(resolveJsonFilePath(cDir, model, locale), { force: true });
+			removed.push(model.i18n ? `content/${model.domain}/${model.id}/${locale}.json` : `content/${model.domain}/${model.id}/data.json`);
+			await deleteMeta(projectRoot, model, { locale: model.i18n ? locale : void 0 });
+			break;
+		}
+		case "dictionary": {
+			if (model.i18n && !opts.locale) throw new Error("Dictionary delete requires a locale when i18n is enabled");
+			const locale = opts.locale ?? "data";
+			const filePath = resolveJsonFilePath(cDir, model, locale);
+			if (opts.keys?.length) {
+				const existing = await readJson(filePath) ?? {};
+				const notFound = [];
+				for (const key of opts.keys) if (key in existing) delete existing[key];
+				else notFound.push(key);
+				if (notFound.length > 0) throw new Error(`Dictionary "${model.id}" (${locale}): keys not found — [${notFound.join(", ")}]`);
+				await writeJson(filePath, existing);
+				removed.push(...opts.keys.map((k) => `${model.id}/${locale}:${k}`));
+			} else {
+				await rm(filePath, { force: true });
+				removed.push(model.i18n ? `content/${model.domain}/${model.id}/${locale}.json` : `content/${model.domain}/${model.id}/data.json`);
+				await deleteMeta(projectRoot, model, { locale: model.i18n ? locale : void 0 });
+			}
+			break;
+		}
+	}
+	return removed;
+}
+async function listContent(projectRoot, model, opts, config) {
+	const cDir = resolveContentDir(projectRoot, model);
+	const locale = opts.locale ?? config.locales.default;
+	switch (model.kind) {
+		case "singleton": return {
+			kind: "singleton",
+			data: await readJson(resolveJsonFilePath(cDir, model, locale)) ?? {},
+			locale
+		};
+		case "collection": {
+			const data = await readJson(resolveJsonFilePath(cDir, model, locale)) ?? {};
+			let entries = Object.entries(data).map(([id, fields]) => {
+				const entry = { id };
+				Object.assign(entry, fields);
+				return entry;
+			});
+			if (opts.filter) entries = entries.filter((entry) => {
+				for (const [key, value] of Object.entries(opts.filter)) if (entry[key] !== value) return false;
+				return true;
+			});
+			const total = entries.length;
+			const offset = opts.offset ?? 0;
+			const limit = opts.limit ?? entries.length;
+			entries = entries.slice(offset, offset + limit);
+			if (opts.resolve && model.fields) entries = await resolveRelations(projectRoot, model, entries, locale);
+			return {
+				kind: "collection",
+				data: entries,
+				total,
+				locale,
+				offset,
+				limit
+			};
+		}
+		case "document": {
+			const entries = [];
+			const strategy = resolveLocaleStrategy(model);
+			if (!model.i18n) {
+				const files = await readDir(cDir);
+				for (const f of files) {
+					if (!f.endsWith(".md")) continue;
+					const slug = f.replace(".md", "");
+					const raw = await readText(join(cDir, f));
+					if (!raw) continue;
+					const { frontmatter, body } = parseFrontmatter(raw);
+					entries.push({
+						slug,
+						frontmatter,
+						body
+					});
+				}
+			} else if (strategy === "file") {
+				const slugDirs = await readDir(cDir);
+				for (const slug of slugDirs) {
+					const raw = await readText(join(cDir, slug, `${locale}.md`));
+					if (!raw) continue;
+					const { frontmatter, body } = parseFrontmatter(raw);
+					entries.push({
+						slug,
+						frontmatter,
+						body
+					});
+				}
+			} else if (strategy === "suffix") {
+				const files = await readDir(cDir);
+				const suffix = `.${locale}.md`;
+				for (const f of files) {
+					if (!f.endsWith(suffix)) continue;
+					const slug = f.slice(0, -suffix.length);
+					const raw = await readText(join(cDir, f));
+					if (!raw) continue;
+					const { frontmatter, body } = parseFrontmatter(raw);
+					entries.push({
+						slug,
+						frontmatter,
+						body
+					});
+				}
+			} else if (strategy === "directory") {
+				const localeDir = join(cDir, locale);
+				const files = await readDir(localeDir);
+				for (const f of files) {
+					if (!f.endsWith(".md")) continue;
+					const slug = f.replace(".md", "");
+					const raw = await readText(join(localeDir, f));
+					if (!raw) continue;
+					const { frontmatter, body } = parseFrontmatter(raw);
+					entries.push({
+						slug,
+						frontmatter,
+						body
+					});
+				}
+			} else {
+				const files = await readDir(cDir);
+				for (const f of files) {
+					if (!f.endsWith(".md")) continue;
+					const slug = f.replace(".md", "");
+					const raw = await readText(join(cDir, f));
+					if (!raw) continue;
+					const { frontmatter, body } = parseFrontmatter(raw);
+					entries.push({
+						slug,
+						frontmatter,
+						body
+					});
+				}
+			}
+			const total = entries.length;
+			const offset = opts.offset ?? 0;
+			const limit = opts.limit ?? entries.length;
+			return {
+				kind: "document",
+				data: entries.slice(offset, offset + limit),
+				total,
+				locale,
+				offset,
+				limit
+			};
+		}
+		case "dictionary": {
+			const data = await readJson(resolveJsonFilePath(cDir, model, locale)) ?? {};
+			return {
+				kind: "dictionary",
+				data,
+				total_keys: Object.keys(data).length,
+				locale
+			};
+		}
+	}
+}
+async function readContent(projectRoot, model, opts) {
+	const cDir = resolveContentDir(projectRoot, model);
+	switch (model.kind) {
+		case "singleton": return readJson(resolveJsonFilePath(cDir, model, opts.locale));
+		case "collection": {
+			if (!opts.entryId) return null;
+			const data = await readJson(resolveJsonFilePath(cDir, model, opts.locale));
+			return data?.[opts.entryId] ? {
+				id: opts.entryId,
+				...data[opts.entryId]
+			} : null;
+		}
+		case "document": {
+			if (!opts.slug) return null;
+			const raw = await readText(resolveMdFilePath(cDir, model, opts.locale, opts.slug));
+			if (!raw) return null;
+			const { frontmatter, body } = parseFrontmatter(raw);
+			return {
+				slug: opts.slug,
+				...frontmatter,
+				body
+			};
+		}
+		case "dictionary": return readJson(resolveJsonFilePath(cDir, model, opts.locale));
+	}
+}
+async function resolveRelations(projectRoot, model, entries, locale) {
+	if (!model.fields) return entries;
+	const relationFields = [];
+	for (const [name, field] of Object.entries(model.fields)) if (field.type === "relation" || field.type === "relations") {
+		const targets = Array.isArray(field.model) ? field.model : field.model ? [field.model] : [];
+		relationFields.push({
+			name,
+			targetModels: targets,
+			multi: field.type === "relations"
+		});
+	}
+	if (relationFields.length === 0) return entries;
+	const targetCache = {};
+	const visited = new Set([model.id]);
+	for (const rf of relationFields) for (const targetModelId of rf.targetModels) {
+		if (targetCache[targetModelId] || visited.has(targetModelId)) continue;
+		visited.add(targetModelId);
+		const targetModel = await readModel(projectRoot, targetModelId);
+		if (!targetModel) continue;
+		if (targetModel.kind === "collection") targetCache[targetModelId] = await readJson(resolveJsonFilePath(resolveContentDir(projectRoot, targetModel), targetModel, locale)) ?? {};
+		else if (targetModel.kind === "document") {
+			const docCache = {};
+			const cDir = resolveContentDir(projectRoot, targetModel);
+			const strategy = resolveLocaleStrategy(targetModel);
+			if (!targetModel.i18n) {
+				const files = await readDir(cDir);
+				for (const f of files) {
+					if (!f.endsWith(".md")) continue;
+					const slug = f.replace(".md", "");
+					const raw = await readText(join(cDir, f));
+					if (!raw) continue;
+					const { frontmatter, body } = parseFrontmatter(raw);
+					docCache[slug] = {
+						slug,
+						...frontmatter,
+						body
+					};
+				}
+			} else if (strategy === "file") {
+				const slugDirs = await readDir(cDir);
+				for (const slug of slugDirs) {
+					const raw = await readText(join(cDir, slug, `${locale}.md`));
+					if (!raw) continue;
+					const { frontmatter, body } = parseFrontmatter(raw);
+					docCache[slug] = {
+						slug,
+						...frontmatter,
+						body
+					};
+				}
+			} else if (strategy === "suffix") {
+				const files = await readDir(cDir);
+				const suffix = `.${locale}.md`;
+				for (const f of files) {
+					if (!f.endsWith(suffix)) continue;
+					const slug = f.slice(0, -suffix.length);
+					const raw = await readText(join(cDir, f));
+					if (!raw) continue;
+					const { frontmatter, body } = parseFrontmatter(raw);
+					docCache[slug] = {
+						slug,
+						...frontmatter,
+						body
+					};
+				}
+			} else if (strategy === "directory") {
+				const localeDir = join(cDir, locale);
+				const files = await readDir(localeDir);
+				for (const f of files) {
+					if (!f.endsWith(".md")) continue;
+					const slug = f.replace(".md", "");
+					const raw = await readText(join(localeDir, f));
+					if (!raw) continue;
+					const { frontmatter, body } = parseFrontmatter(raw);
+					docCache[slug] = {
+						slug,
+						...frontmatter,
+						body
+					};
+				}
+			} else {
+				const files = await readDir(cDir);
+				for (const f of files) {
+					if (!f.endsWith(".md")) continue;
+					const slug = f.replace(".md", "");
+					const raw = await readText(join(cDir, f));
+					if (!raw) continue;
+					const { frontmatter, body } = parseFrontmatter(raw);
+					docCache[slug] = {
+						slug,
+						...frontmatter,
+						body
+					};
+				}
+			}
+			targetCache[targetModelId] = docCache;
+		}
+	}
+	return entries.map((entry) => {
+		const resolved = { ...entry };
+		for (const rf of relationFields) {
+			const value = resolved[rf.name];
+			if (!value) continue;
+			if (rf.multi && Array.isArray(value)) resolved[rf.name] = value.map((id) => {
+				for (const targetModelId of rf.targetModels) {
+					const cached = targetCache[targetModelId]?.[id];
+					if (cached) return {
+						id,
+						...cached
+					};
+				}
+				return id;
+			});
+			else if (typeof value === "string") for (const targetModelId of rf.targetModels) {
+				const cached = targetCache[targetModelId]?.[value];
+				if (cached) {
+					resolved[rf.name] = {
+						id: value,
+						...cached
+					};
+					break;
+				}
+			}
+		}
+		return resolved;
+	});
+}
+//#endregion
+//#region src/core/model-manager.ts
+async function listModels(projectRoot) {
+	const modelsDir = join(contentrainDir(projectRoot), "models");
+	const jsonFiles = (await readDir(modelsDir)).filter((f) => f.endsWith(".json"));
+	return (await Promise.all(jsonFiles.map((file) => readJson(join(modelsDir, file))))).filter((m) => m !== null && !!m.id).map((model) => ({
+		id: model.id,
+		kind: model.kind,
+		domain: model.domain,
+		i18n: model.i18n,
+		fields: model.fields ? Object.keys(model.fields).length : 0
+	})).toSorted((a, b) => a.id.localeCompare(b.id, "en"));
+}
+async function readModel(projectRoot, modelId) {
+	return readJson(join(contentrainDir(projectRoot), "models", `${modelId}.json`));
+}
+async function countDocumentFileStrategy(contentDir, entries) {
+	const locales = {};
+	let total = 0;
+	const results = await Promise.all(entries.map(async (entry) => {
+		const localeFiles = await readDir(join(contentDir, entry));
+		return localeFiles.map((lf) => lf.replace(/\.(json|md|mdx)$/, "")).filter((locale, i) => locale !== localeFiles[i]);
+	}));
+	for (const entryLocales of results) for (const locale of entryLocales) {
+		locales[locale] = (locales[locale] ?? 0) + 1;
+		total++;
+	}
+	return {
+		total,
+		locales
+	};
+}
+async function countDocumentSuffixStrategy(contentDir, files) {
+	const locales = {};
+	const slugsByLocale = {};
+	for (const f of files) {
+		if (!f.endsWith(".md")) continue;
+		const match = f.match(/^(.+)\.([a-z]{2}(?:-[A-Z]{2})?)\.md$/);
+		if (!match) continue;
+		const locale = match[2];
+		if (!slugsByLocale[locale]) slugsByLocale[locale] = /* @__PURE__ */ new Set();
+		slugsByLocale[locale].add(match[1]);
+	}
+	let total = 0;
+	for (const [locale, slugs] of Object.entries(slugsByLocale)) {
+		locales[locale] = slugs.size;
+		total += slugs.size;
+	}
+	return {
+		total,
+		locales
+	};
+}
+async function countDocumentDirectoryStrategy(contentDir, localeDirs) {
+	const locales = {};
+	let total = 0;
+	const results = await Promise.all(localeDirs.map(async (localeDir) => {
+		return {
+			locale: localeDir,
+			count: (await readDir(join(contentDir, localeDir))).filter((f) => f.endsWith(".md")).length
+		};
+	}));
+	for (const { locale, count } of results) {
+		locales[locale] = count;
+		total += count;
+	}
+	return {
+		total,
+		locales
+	};
+}
+async function countDocumentNoneStrategy(projectRoot, modelId, files, i18n) {
+	const mdFiles = files.filter((f) => f.endsWith(".md"));
+	if (!i18n) return {
+		total: mdFiles.length,
+		locales: { _: mdFiles.length }
+	};
+	const metaDir = join(contentrainDir(projectRoot), "meta", modelId);
+	const locales = {};
+	let total = 0;
+	const slugs = mdFiles.map((f) => f.replace(".md", ""));
+	const results = await Promise.all(slugs.map(async (slug) => {
+		return (await readDir(join(metaDir, slug))).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+	}));
+	for (const slugLocales of results) for (const locale of slugLocales) {
+		locales[locale] = (locales[locale] ?? 0) + 1;
+		total++;
+	}
+	return {
+		total,
+		locales
+	};
+}
+async function countCollectionEntries(contentDir, jsonFiles) {
+	const locales = {};
+	let total = 0;
+	const results = await Promise.all(jsonFiles.map(async (file) => {
+		const locale = file.replace(/\.json$/, "");
+		const data = await readJson(join(contentDir, file));
+		return {
+			locale,
+			count: data ? Object.keys(data).length : 0
+		};
+	}));
+	for (const { locale, count } of results) {
+		locales[locale] = count;
+		total += count;
+	}
+	return {
+		total,
+		locales
+	};
+}
+async function countEntries(projectRoot, model) {
+	const cDir = resolveContentDir(projectRoot, model);
+	const strategy = resolveLocaleStrategy(model);
+	const files = await readDir(cDir);
+	if (model.kind === "document") {
+		if (!model.i18n) return countDocumentNoneStrategy(projectRoot, model.id, files, false);
+		switch (strategy) {
+			case "file": return countDocumentFileStrategy(cDir, files);
+			case "suffix": return countDocumentSuffixStrategy(cDir, files);
+			case "directory": return countDocumentDirectoryStrategy(cDir, files);
+			case "none": return countDocumentNoneStrategy(projectRoot, model.id, files, true);
+		}
+	}
+	if (model.kind === "collection") {
+		if (!model.i18n) return countCollectionEntries(cDir, files.filter((f) => f.endsWith(".json")));
+		switch (strategy) {
+			case "suffix": {
+				const jsonFiles = files.filter((f) => f.endsWith(".json"));
+				const locales = {};
+				for (const f of jsonFiles) {
+					const match = f.match(/^.+\.([a-z]{2}(?:-[A-Z]{2})?)\.json$/);
+					if (match) {
+						const data = await readJson(join(cDir, f));
+						locales[match[1]] = data ? Object.keys(data).length : 0;
+					}
+				}
+				return {
+					total: Object.values(locales).reduce((a, b) => a + b, 0),
+					locales
+				};
+			}
+			case "directory": {
+				const locales = {};
+				let total = 0;
+				for (const localeDir of files) {
+					const jsonFile = (await readDir(join(cDir, localeDir))).find((f) => f.endsWith(".json"));
+					if (jsonFile) {
+						const data = await readJson(join(cDir, localeDir, jsonFile));
+						const count = data ? Object.keys(data).length : 0;
+						locales[localeDir] = count;
+						total += count;
+					}
+				}
+				return {
+					total,
+					locales
+				};
+			}
+			case "none": {
+				const noneFile = files.find((f) => f === `${model.id}.json`);
+				if (!noneFile) return {
+					total: 0,
+					locales: {}
+				};
+				const data = await readJson(join(cDir, noneFile));
+				const count = data ? Object.keys(data).length : 0;
+				return {
+					total: count,
+					locales: { _: count }
+				};
+			}
+			default: return countCollectionEntries(cDir, files.filter((f) => f.endsWith(".json")));
+		}
+	}
+	if (!model.i18n) return {
+		total: files.some((f) => f === "data.json") ? 1 : 0,
+		locales: {}
+	};
+	switch (strategy) {
+		case "suffix": {
+			const locales = {};
+			for (const f of files) {
+				const match = f.match(/^.+\.([a-z]{2}(?:-[A-Z]{2})?)\.json$/);
+				if (match) locales[match[1]] = 1;
+			}
+			return {
+				total: Object.keys(locales).length,
+				locales
+			};
+		}
+		case "directory": {
+			const locales = {};
+			for (const localeDir of files) if ((await readDir(join(cDir, localeDir))).some((f) => f.endsWith(".json"))) locales[localeDir] = 1;
+			return {
+				total: Object.keys(locales).length,
+				locales
+			};
+		}
+		case "none": return {
+			total: files.some((f) => f === `${model.id}.json`) ? 1 : 0,
+			locales: {}
+		};
+		default: {
+			const jsonFiles = files.filter((f) => f.endsWith(".json"));
+			const locales = {};
+			for (const file of jsonFiles) locales[file.replace(/\.json$/, "")] = 1;
+			return {
+				total: jsonFiles.length,
+				locales
+			};
+		}
+	}
+}
+const MODEL_FIELD_ORDER = [
+	"id",
+	"name",
+	"kind",
+	"domain",
+	"i18n",
+	"description",
+	"content_path",
+	"locale_strategy",
+	"fields"
+];
+async function writeModel(projectRoot, model) {
+	await writeJson(join(contentrainDir(projectRoot), "models", `${model.id}.json`), model, MODEL_FIELD_ORDER);
+	await ensureDir(resolveContentDir(projectRoot, model));
+	await ensureDir(join(contentrainDir(projectRoot), "meta", model.id));
+}
+async function deleteModel(projectRoot, modelId) {
+	const model = await readModel(projectRoot, modelId);
+	if (!model) return [];
+	const crDir = contentrainDir(projectRoot);
+	const removed = [];
+	const modelPath = join(crDir, "models", `${modelId}.json`);
+	const contentPath = resolveContentDir(projectRoot, model);
+	const metaPath = join(crDir, "meta", modelId);
+	await rm(modelPath, { force: true });
+	removed.push(`models/${modelId}.json`);
+	try {
+		await rm(contentPath, {
+			recursive: true,
+			force: true
+		});
+		removed.push(model.content_path ?? `content/${model.domain}/${modelId}/`);
+	} catch {}
+	try {
+		await rm(metaPath, {
+			recursive: true,
+			force: true
+		});
+		removed.push(`meta/${modelId}/`);
+	} catch {}
+	return removed;
+}
+async function checkReferences(projectRoot, modelId) {
+	const others = (await listModels(projectRoot)).filter((s) => s.id !== modelId);
+	const models = await Promise.all(others.map((s) => readModel(projectRoot, s.id)));
+	const refs = [];
+	for (const model of models) {
+		if (!model?.fields) continue;
+		for (const [fieldName, fieldDef] of Object.entries(model.fields)) {
+			if (fieldDef.type !== "relation" && fieldDef.type !== "relations") continue;
+			if ((Array.isArray(fieldDef.model) ? fieldDef.model : [fieldDef.model]).includes(modelId)) refs.push({
+				model: model.id,
+				field: fieldName,
+				type: fieldDef.type
+			});
+		}
+	}
+	return refs;
+}
+const FIELD_TYPE_ENUM = [
+	"string",
+	"text",
+	"email",
+	"url",
+	"slug",
+	"color",
+	"phone",
+	"code",
+	"icon",
+	"markdown",
+	"richtext",
+	"number",
+	"integer",
+	"decimal",
+	"percent",
+	"rating",
+	"boolean",
+	"date",
+	"datetime",
+	"image",
+	"video",
+	"file",
+	"relation",
+	"relations",
+	"select",
+	"array",
+	"object"
+];
+/**
+* Shared Zod schema for field definitions.
+* Used by both model_save and normalize extract for full parity.
+*/
+const fieldDefZodSchema = z.record(z.string(), z.object({
+	type: z.enum(FIELD_TYPE_ENUM).describe("Field type from the 27-type catalog"),
+	required: z.boolean().optional(),
+	unique: z.boolean().optional(),
+	default: z.unknown().optional(),
+	min: z.number().optional(),
+	max: z.number().optional(),
+	pattern: z.string().optional(),
+	options: z.array(z.string()).optional(),
+	model: z.union([z.string(), z.array(z.string())]).optional(),
+	items: z.union([z.string(), z.lazy(() => z.record(z.string(), z.unknown()))]).optional(),
+	fields: z.lazy(() => z.record(z.string(), z.unknown())).optional(),
+	accept: z.string().optional(),
+	maxSize: z.number().optional(),
+	description: z.string().optional()
+}).refine((f) => {
+	if ((f.type === "relation" || f.type === "relations") && !f.model) return false;
+	if (f.type === "select" && (!f.options || f.options.length === 0)) return false;
+	return true;
+}, { message: "relation/relations requires \"model\", select requires non-empty \"options\"" }));
+const VALID_FIELD_TYPES = new Set(FIELD_TYPE_ENUM);
+/**
+* Validate a model definition before writing.
+* Returns array of error messages (empty = valid).
+* Used by both model_save tool and normalize extract.
+*/
+function validateModelDefinition(input) {
+	const errors = [];
+	if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(input.id)) errors.push(`Invalid model ID "${input.id}": must be kebab-case`);
+	if (input.kind === "dictionary" && input.fields && Object.keys(input.fields).length > 0) errors.push("Dictionary models cannot have fields. Dictionaries store flat key-value pairs.");
+	if (input.fields) for (const [fieldName, fieldDef] of Object.entries(input.fields)) {
+		const def = fieldDef;
+		if (!/^[a-z][a-z0-9_]*$/.test(fieldName)) errors.push(`Field "${fieldName}": invalid name — must be snake_case starting with letter`);
+		if (!def.type || !VALID_FIELD_TYPES.has(def.type)) errors.push(`Field "${fieldName}": invalid type "${def.type}"`);
+		if ((def.type === "relation" || def.type === "relations") && !def.model) errors.push(`Field "${fieldName}": ${def.type} type requires "model" property`);
+		if (def.type === "select" && (!def.options || !Array.isArray(def.options) || def.options.length === 0)) errors.push(`Field "${fieldName}": select type requires non-empty "options" array`);
+	}
+	return errors;
+}
+//#endregion
+export { writeContent as S, resolveMdFilePath as _, fieldDefZodSchema as a, validateLocale as b, validateModelDefinition as c, listContent as d, parseFrontmatter as f, resolveLocaleStrategy as g, resolveJsonFilePath as h, deleteModel as i, writeModel as l, resolveContentDir as m, checkReferences as n, listModels as o, readContent as p, countEntries as r, readModel as s, FIELD_TYPE_ENUM as t, deleteContent as u, serializeFrontmatter as v, validateSlug as x, validateEntryId as y };
+
+//# sourceMappingURL=model-manager-sfPdrVIJ.mjs.map