@contentrain/mcp 1.2.0 → 1.3.0

package/dist/{model-manager-DW_fOGRM.mjs → model-manager-BhLsUgaB.mjs}

@@ -1,9 +1,46 @@
-import { a as readJson, c as writeText, i as readDir, n as ensureDir, o as readText, s as writeJson, t as contentrainDir } from "./fs-BnIQ4dKj.mjs";
-import { r as writeMeta, t as deleteMeta } from "./meta-manager--0IwAPCl.mjs";
-import { join } from "node:path";
+import { n as contentFilePath, r as documentFilePath, t as contentDirPath } from "./paths-CYl5vCBD.mjs";
+import { a as readJson, c as writeText, i as readDir, n as ensureDir, o as readText, s as writeJson, t as contentrainDir } from "./fs-DLbVB-Ek.mjs";
+import { r as writeMeta, t as deleteMeta } from "./meta-manager-C900rEyG.mjs";
+import { join, resolve } from "node:path";
+import { generateEntryId, parseMarkdownFrontmatter, parseMarkdownFrontmatter as parseFrontmatter, serializeMarkdownFrontmatter, serializeMarkdownFrontmatter as serializeFrontmatter, validateEntryId as validateEntryId$1, validateLocale as validateLocale$1, validateSlug as validateSlug$1 } from "@contentrain/types";
+import { access, readFile, readdir, rm } from "node:fs/promises";
 import { z } from "zod";
-import { rm } from "node:fs/promises";
-import { generateEntryId, parseMarkdownFrontmatter, parseMarkdownFrontmatter as parseFrontmatter, serializeMarkdownFrontmatter, serializeMarkdownFrontmatter as serializeFrontmatter, validateEntryId, validateLocale, validateSlug } from "@contentrain/types";
+//#region src/providers/local/reader.ts
+/**
+* LocalReader — `RepoReader` backed by the local filesystem.
+*
+* Paths may be absolute or relative to `projectRoot` (`node:path/resolve`
+* handles both). The `ref` parameter is accepted for interface compatibility
+* but ignored because LocalReader always reads from the working tree.
+*
+* Phase 1: provided as plumbing; core ops still use direct `fs` calls.
+* Phase 2 routes ops through this reader (and through GitHubProvider's reader
+* in Phase 5) so the same op surface works on every backing store.
+*/
+var LocalReader = class {
+	constructor(projectRoot) {
+		this.projectRoot = projectRoot;
+	}
+	async readFile(path, _ref) {
+		return readFile(resolve(this.projectRoot, path), "utf-8");
+	}
+	async listDirectory(path, _ref) {
+		try {
+			return await readdir(resolve(this.projectRoot, path));
+		} catch {
+			return [];
+		}
+	}
+	async fileExists(path, _ref) {
+		try {
+			await access(resolve(this.projectRoot, path));
+			return true;
+		} catch {
+			return false;
+		}
+	}
+};
+//#endregion
 //#region src/core/content-manager.ts
 function resolveContentDir(projectRoot, model) {
 	if (model.content_path) return join(projectRoot, model.content_path);
@@ -42,19 +79,19 @@ function defaultMeta(data) {
 	if (data?.["expire_at"] !== void 0) meta.expire_at = data["expire_at"];
 	return meta;
 }
-async function writeContent(projectRoot, model, entries, config) {
+async function writeContent(projectRoot, model, entries, config, vocabulary) {
 	const results = [];
 	const defaultLocale = config.locales.default;
 	for (const entry of entries) {
 		const locale = entry.locale ?? defaultLocale;
-		const localeErr = validateLocale(locale, config);
+		const localeErr = validateLocale$1(locale, config);
 		if (localeErr) throw new Error(localeErr);
 		if (entry.id) {
-			const idErr = validateEntryId(entry.id);
+			const idErr = validateEntryId$1(entry.id);
 			if (idErr) throw new Error(idErr);
 		}
 		if (entry.slug) {
-			const slugErr = validateSlug(entry.slug);
+			const slugErr = validateSlug$1(entry.slug);
 			if (slugErr) throw new Error(slugErr);
 		}
 		switch (model.kind) {
@@ -90,7 +127,7 @@ async function writeContent(projectRoot, model, entries, config) {
 			case "document": {
 				const slug = entry.slug ?? entry.data["slug"];
 				if (!slug) throw new Error("Document entries require a slug");
-				const slugErr = validateSlug(slug);
+				const slugErr = validateSlug$1(slug);
 				if (slugErr) throw new Error(slugErr);
 				const bodyContent = entry.data["body"] ?? "";
 				const fmData = { ...entry.data };
@@ -116,6 +153,21 @@ async function writeContent(projectRoot, model, entries, config) {
 				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.`);
+				const advisories = [];
+				const reverseMap = /* @__PURE__ */ new Map();
+				for (const [k, v] of Object.entries(existing)) reverseMap.set(v, k);
+				for (const [newKey, newValue] of Object.entries(entry.data)) {
+					if (newKey in existing) continue;
+					const existingKey = reverseMap.get(newValue);
+					if (existingKey && existingKey !== newKey) advisories.push(`Value "${newValue}" already exists as key "${existingKey}". Consider reusing instead of creating "${newKey}".`);
+				}
+				if (vocabulary && Object.keys(vocabulary.terms).length > 0) for (const [newKey, newValue] of Object.entries(entry.data)) {
+					if (newKey in existing) continue;
+					for (const [, translations] of Object.entries(vocabulary.terms)) if (Object.values(translations).includes(newValue)) {
+						advisories.push(`Value "${newValue}" matches a vocabulary term. Use the canonical form for consistency.`);
+						break;
+					}
+				}
 				await writeJson(filePath, {
 					...existing,
 					...entry.data
@@ -123,7 +175,8 @@ async function writeContent(projectRoot, model, entries, config) {
 				await writeMeta(projectRoot, model, { locale }, defaultMeta(entry.data));
 				results.push({
 					action: "updated",
-					locale
+					locale,
+					...advisories.length > 0 ? { advisories } : {}
 				});
 				break;
 			}
@@ -155,7 +208,7 @@ async function deleteContent(projectRoot, model, opts) {
 		}
 		case "document": {
 			if (!opts.slug) throw new Error("Document delete requires a slug");
-			const slugDelErr = validateSlug(opts.slug);
+			const slugDelErr = validateSlug$1(opts.slug);
 			if (slugDelErr) throw new Error(slugDelErr);
 			const strategy = resolveLocaleStrategy(model);
 			if (!model.i18n) await rm(join(cDir, `${opts.slug}.md`), { force: true });
@@ -209,7 +262,11 @@ async function deleteContent(projectRoot, model, opts) {
 	}
 	return removed;
 }
-async function listContent(projectRoot, model, opts, config) {
+async function listContent(input, model, opts, config) {
+	if (typeof input !== "string") return listContentViaReader(input, model, opts, config);
+	return listContentLocal(input, model, opts, config);
+}
+async function listContentLocal(projectRoot, model, opts, config) {
 	const cDir = resolveContentDir(projectRoot, model);
 	const locale = opts.locale ?? config.locales.default;
 	switch (model.kind) {
@@ -340,6 +397,122 @@ async function listContent(projectRoot, model, opts, config) {
 		}
 	}
 }
+async function tryReadJsonViaReader$1(reader, path) {
+	try {
+		return JSON.parse(await reader.readFile(path));
+	} catch {
+		return null;
+	}
+}
+async function tryReadTextViaReader(reader, path) {
+	try {
+		return await reader.readFile(path);
+	} catch {
+		return null;
+	}
+}
+async function listContentViaReader(reader, model, opts, config) {
+	if (opts.resolve) throw new Error("contentrain_content_list with resolve:true requires local filesystem access. Use a LocalProvider (stdio or HTTP+LocalProvider) or omit resolve:true.");
+	const cDir = contentDirPath(model);
+	const locale = opts.locale ?? config.locales.default;
+	switch (model.kind) {
+		case "singleton": return {
+			kind: "singleton",
+			data: await tryReadJsonViaReader$1(reader, contentFilePath(model, locale)) ?? {},
+			locale
+		};
+		case "collection": {
+			const data = await tryReadJsonViaReader$1(reader, contentFilePath(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);
+			return {
+				kind: "collection",
+				data: entries,
+				total,
+				locale,
+				offset,
+				limit
+			};
+		}
+		case "document": {
+			const entries = [];
+			const strategy = resolveLocaleStrategy(model);
+			const collectEntry = async (relPath, slug) => {
+				const raw = await tryReadTextViaReader(reader, relPath);
+				if (!raw) return;
+				const { frontmatter, body } = parseMarkdownFrontmatter(raw);
+				entries.push({
+					slug,
+					frontmatter,
+					body
+				});
+			};
+			if (!model.i18n) {
+				const files = await reader.listDirectory(cDir);
+				for (const f of files) {
+					if (!f.endsWith(".md")) continue;
+					await collectEntry(documentFilePath(model, locale, f.replace(/\.md$/u, "")), f.replace(/\.md$/u, ""));
+				}
+			} else if (strategy === "file") {
+				const slugDirs = await reader.listDirectory(cDir);
+				for (const slug of slugDirs) await collectEntry(documentFilePath(model, locale, slug), slug);
+			} else if (strategy === "suffix") {
+				const files = await reader.listDirectory(cDir);
+				const suffix = `.${locale}.md`;
+				for (const f of files) {
+					if (!f.endsWith(suffix)) continue;
+					const slug = f.slice(0, -suffix.length);
+					await collectEntry(documentFilePath(model, locale, slug), slug);
+				}
+			} else if (strategy === "directory") {
+				const files = await reader.listDirectory(`${cDir}/${locale}`);
+				for (const f of files) {
+					if (!f.endsWith(".md")) continue;
+					const slug = f.replace(/\.md$/u, "");
+					await collectEntry(documentFilePath(model, locale, slug), slug);
+				}
+			} else {
+				const files = await reader.listDirectory(cDir);
+				for (const f of files) {
+					if (!f.endsWith(".md")) continue;
+					const slug = f.replace(/\.md$/u, "");
+					await collectEntry(documentFilePath(model, locale, slug), slug);
+				}
+			}
+			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 tryReadJsonViaReader$1(reader, contentFilePath(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) {
@@ -495,10 +668,27 @@ async function resolveRelations(projectRoot, model, entries, locale) {
 }
 //#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) => ({
+const MODELS_DIR_PATH = ".contentrain/models";
+async function tryReadJsonViaReader(reader, path) {
+	try {
+		return JSON.parse(await reader.readFile(path));
+	} catch {
+		return null;
+	}
+}
+async function listModels(input) {
+	let files;
+	let load;
+	if (typeof input === "string") {
+		const modelsDir = join(contentrainDir(input), "models");
+		files = await readDir(modelsDir);
+		load = (file) => readJson(join(modelsDir, file));
+	} else {
+		files = await input.listDirectory(MODELS_DIR_PATH);
+		load = (file) => tryReadJsonViaReader(input, `${MODELS_DIR_PATH}/${file}`);
+	}
+	const jsonFiles = files.filter((f) => f.endsWith(".json"));
+	return (await Promise.all(jsonFiles.map(load))).filter((m) => m !== null && !!m.id).map((model) => ({
 		id: model.id,
 		kind: model.kind,
 		domain: model.domain,
@@ -506,14 +696,15 @@ async function listModels(projectRoot) {
 		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 readModel(input, modelId) {
+	if (typeof input === "string") return readJson(join(contentrainDir(input), "models", `${modelId}.json`));
+	return tryReadJsonViaReader(input, `${MODELS_DIR_PATH}/${modelId}.json`);
 }
-async function countDocumentFileStrategy(contentDir, entries) {
+async function countDocumentFileStrategy(reader, contentDir, entries) {
 	const locales = {};
 	let total = 0;
 	const results = await Promise.all(entries.map(async (entry) => {
-		const localeFiles = await readDir(join(contentDir, entry));
+		const localeFiles = await reader.listDirectory(`${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) {
@@ -525,7 +716,7 @@ async function countDocumentFileStrategy(contentDir, entries) {
 		locales
 	};
 }
-async function countDocumentSuffixStrategy(_contentDir, files) {
+async function countDocumentSuffixStrategy(_reader, _contentDir, files) {
 	const locales = {};
 	const slugsByLocale = {};
 	for (const f of files) {
@@ -546,13 +737,13 @@ async function countDocumentSuffixStrategy(_contentDir, files) {
 		locales
 	};
 }
-async function countDocumentDirectoryStrategy(contentDir, localeDirs) {
+async function countDocumentDirectoryStrategy(reader, 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
+			count: (await reader.listDirectory(`${contentDir}/${localeDir}`)).filter((f) => f.endsWith(".md")).length
 		};
 	}));
 	for (const { locale, count } of results) {
@@ -564,18 +755,18 @@ async function countDocumentDirectoryStrategy(contentDir, localeDirs) {
 		locales
 	};
 }
-async function countDocumentNoneStrategy(projectRoot, modelId, files, i18n) {
+async function countDocumentNoneStrategy(reader, 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 metaDir = `.contentrain/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", ""));
+		return (await reader.listDirectory(`${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;
@@ -586,12 +777,12 @@ async function countDocumentNoneStrategy(projectRoot, modelId, files, i18n) {
 		locales
 	};
 }
-async function countCollectionEntries(contentDir, jsonFiles) {
+async function countCollectionEntries(reader, 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));
+		const data = await tryReadJsonViaReader(reader, `${contentDir}/${file}`);
 		return {
 			locale,
 			count: data ? Object.keys(data).length : 0
@@ -606,21 +797,22 @@ async function countCollectionEntries(contentDir, jsonFiles) {
 		locales
 	};
 }
-async function countEntries(projectRoot, model) {
-	const cDir = resolveContentDir(projectRoot, model);
+async function countEntries(input, model) {
+	const reader = typeof input === "string" ? new LocalReader(input) : input;
+	const cDir = contentDirPath(model);
 	const strategy = resolveLocaleStrategy(model);
-	const files = await readDir(cDir);
+	const files = await reader.listDirectory(cDir);
 	if (model.kind === "document") {
-		if (!model.i18n) return countDocumentNoneStrategy(projectRoot, model.id, files, false);
+		if (!model.i18n) return countDocumentNoneStrategy(reader, 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);
+			case "file": return countDocumentFileStrategy(reader, cDir, files);
+			case "suffix": return countDocumentSuffixStrategy(reader, cDir, files);
+			case "directory": return countDocumentDirectoryStrategy(reader, cDir, files);
+			case "none": return countDocumentNoneStrategy(reader, model.id, files, true);
 		}
 	}
 	if (model.kind === "collection") {
-		if (!model.i18n) return countCollectionEntries(cDir, files.filter((f) => f.endsWith(".json")));
+		if (!model.i18n) return countCollectionEntries(reader, cDir, files.filter((f) => f.endsWith(".json")));
 		switch (strategy) {
 			case "suffix": {
 				const jsonFiles = files.filter((f) => f.endsWith(".json"));
@@ -628,7 +820,7 @@ async function countEntries(projectRoot, model) {
 				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));
+						const data = await tryReadJsonViaReader(reader, `${cDir}/${f}`);
 						locales[match[1]] = data ? Object.keys(data).length : 0;
 					}
 				}
@@ -641,9 +833,9 @@ async function countEntries(projectRoot, model) {
 				const locales = {};
 				let total = 0;
 				for (const localeDir of files) {
-					const jsonFile = (await readDir(join(cDir, localeDir))).find((f) => f.endsWith(".json"));
+					const jsonFile = (await reader.listDirectory(`${cDir}/${localeDir}`)).find((f) => f.endsWith(".json"));
 					if (jsonFile) {
-						const data = await readJson(join(cDir, localeDir, jsonFile));
+						const data = await tryReadJsonViaReader(reader, `${cDir}/${localeDir}/${jsonFile}`);
 						const count = data ? Object.keys(data).length : 0;
 						locales[localeDir] = count;
 						total += count;
@@ -660,14 +852,14 @@ async function countEntries(projectRoot, model) {
 					total: 0,
 					locales: {}
 				};
-				const data = await readJson(join(cDir, noneFile));
+				const data = await tryReadJsonViaReader(reader, `${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")));
+			default: return countCollectionEntries(reader, cDir, files.filter((f) => f.endsWith(".json")));
 		}
 	}
 	if (!model.i18n) return {
@@ -688,7 +880,7 @@ async function countEntries(projectRoot, model) {
 		}
 		case "directory": {
 			const locales = {};
-			for (const localeDir of files) if ((await readDir(join(cDir, localeDir))).some((f) => f.endsWith(".json"))) locales[localeDir] = 1;
+			for (const localeDir of files) if ((await reader.listDirectory(`${cDir}/${localeDir}`)).some((f) => f.endsWith(".json"))) locales[localeDir] = 1;
 			return {
 				total: Object.keys(locales).length,
 				locales
@@ -751,9 +943,9 @@ async function deleteModel(projectRoot, 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)));
+async function checkReferences(input, modelId) {
+	const others = (typeof input === "string" ? await listModels(input) : await listModels(input)).filter((s) => s.id !== modelId);
+	const models = await Promise.all(others.map((s) => typeof input === "string" ? readModel(input, s.id) : readModel(input, s.id)));
 	const refs = [];
 	for (const model of models) {
 		if (!model?.fields) continue;
@@ -841,6 +1033,6 @@ function validateModelDefinition(input) {
 	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 };
+export { LocalReader as C, writeContent as S, resolveMdFilePath as _, fieldDefZodSchema as a, validateLocale$1 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$1 as x, validateEntryId$1 as y };
 
-//# sourceMappingURL=model-manager-DW_fOGRM.mjs.map
+//# sourceMappingURL=model-manager-BhLsUgaB.mjs.map