contentrain 0.1.0

package/dist/status-kF5miVty.mjs

@@ -0,0 +1,122 @@
+import { n as requireInitialized, r as resolveProjectRoot, t as loadProjectContext } from "./context-An3xrvcP.mjs";
+import { i as pc, n as formatPercent, r as formatTable, t as formatCount } from "./ui-B5mXontH.mjs";
+import { defineCommand } from "citty";
+import { intro, log, outro } from "@clack/prompts";
+import { simpleGit } from "simple-git";
+import { countEntries, readModel } from "@contentrain/mcp/core/model-manager";
+import { validateProject } from "@contentrain/mcp/core/validator";
+//#region src/commands/status.ts
+var status_default = defineCommand({
+	meta: {
+		name: "status",
+		description: "Show project status overview"
+	},
+	args: {
+		root: {
+			type: "string",
+			description: "Project root path",
+			required: false
+		},
+		json: {
+			type: "boolean",
+			description: "JSON output for CI",
+			required: false
+		}
+	},
+	async run({ args }) {
+		const projectRoot = await resolveProjectRoot(args.root);
+		const ctx = await loadProjectContext(projectRoot);
+		if (args.json) {
+			const jsonResult = {
+				initialized: ctx.initialized,
+				config: ctx.config,
+				models: ctx.models,
+				context: ctx.context
+			};
+			if (ctx.initialized && ctx.config) {
+				try {
+					const validation = await validateProject(projectRoot, {});
+					jsonResult["validation"] = {
+						valid: validation.valid,
+						errors: validation.summary.errors,
+						warnings: validation.summary.warnings
+					};
+				} catch {}
+				try {
+					jsonResult["pending_branches"] = (await simpleGit(projectRoot).branch(["--list", "contentrain/*"])).all;
+				} catch {}
+			}
+			process.stdout.write(JSON.stringify(jsonResult, null, 2));
+			return;
+		}
+		intro(pc.bold("contentrain status"));
+		if (!ctx.initialized) {
+			log.warning("Project not initialized. Run `contentrain init` to get started.");
+			outro("");
+			return;
+		}
+		requireInitialized(ctx);
+		log.info(pc.bold("Configuration"));
+		log.message(`  Stack:    ${pc.cyan(ctx.config.stack)}`);
+		log.message(`  Locales:  ${ctx.config.locales.supported.map((l) => l === ctx.config.locales.default ? pc.green(`${l} (default)`) : l).join(", ")}`);
+		log.message(`  Domains:  ${ctx.config.domains.join(", ")}`);
+		log.message(`  Workflow: ${ctx.config.workflow === "auto-merge" ? pc.green("auto-merge") : pc.yellow("review")}`);
+		if (ctx.models.length > 0) {
+			log.info(pc.bold(`\nModels (${ctx.models.length})`));
+			const rows = [];
+			for (const model of ctx.models) {
+				const full = await readModel(projectRoot, model.id);
+				if (!full) continue;
+				const counts = await countEntries(projectRoot, full);
+				const defaultCount = counts.locales[ctx.config.locales.default] ?? 0;
+				let i18nStatus = "—";
+				if (model.i18n && ctx.config.locales.supported.length > 1) {
+					const completions = ctx.config.locales.supported.filter((l) => l !== ctx.config.locales.default).map((l) => counts.locales[l] ?? 0);
+					i18nStatus = formatPercent(completions.length > 0 ? completions.reduce((a, b) => a + b, 0) / completions.length : 0, defaultCount);
+				}
+				rows.push([
+					model.id,
+					model.kind,
+					model.domain,
+					String(counts.total),
+					model.i18n ? i18nStatus : "—"
+				]);
+			}
+			log.message(formatTable([
+				"Model",
+				"Kind",
+				"Domain",
+				"Entries",
+				"i18n"
+			], rows));
+		} else log.message("  No models yet. Run `contentrain init` with a template or create models.");
+		try {
+			const branches = await simpleGit(projectRoot).branch(["--list", "contentrain/*"]);
+			if (branches.all.length > 0) {
+				const count = branches.all.length;
+				if (count >= 80) {
+					log.error(pc.bold(`\nBLOCKED: ${count} active contentrain branches (limit: 80)`));
+					log.message(`  New writes are blocked. Merge or delete old branches with ${pc.cyan("contentrain diff")}.`);
+				} else if (count >= 50) {
+					log.warning(pc.bold(`\nWARNING: ${count} active contentrain branches (limit: 50)`));
+					log.message(`  Consider merging or deleting old branches with ${pc.cyan("contentrain diff")}.`);
+				} else log.info(pc.bold(`\nPending branches (${count})`));
+				for (const branch of branches.all) log.message(`  ${pc.yellow("●")} ${branch}`);
+				log.message(`  Run ${pc.cyan("contentrain diff")} to review.`);
+			}
+		} catch {}
+		if (ctx.context?.lastOperation) {
+			const op = ctx.context.lastOperation;
+			log.info(pc.bold("\nLast operation"));
+			log.message(`  ${op.tool} → ${op.model || "(init)"} @ ${new Date(op.timestamp).toLocaleString()}`);
+		}
+		try {
+			const result = await validateProject(projectRoot);
+			if (result.summary.errors > 0) log.warning(`\n${formatCount(result.summary.errors, "validation error")}. Run ${pc.cyan("contentrain validate --fix")} to fix.`);
+			else log.success("\nValidation: clean");
+		} catch {}
+		outro("");
+	}
+});
+//#endregion
+export { status_default as default };

package/dist/ui-B5mXontH.mjs

@@ -0,0 +1,33 @@
+import pc from "picocolors";
+//#region src/utils/ui.ts
+function severityColor(severity) {
+	switch (severity) {
+		case "error": return pc.red;
+		case "warning": return pc.yellow;
+		case "notice": return pc.blue;
+	}
+}
+function formatCount(n, singular, plural) {
+	return `${n} ${n === 1 ? singular : plural ?? `${singular}s`}`;
+}
+function formatPercent(part, total) {
+	if (total === 0) return "—";
+	const pct = Math.round(part / total * 100);
+	return (pct === 100 ? pc.green : pct >= 75 ? pc.yellow : pc.red)(`${pct}%`);
+}
+function padRight(str, len) {
+	return str.length >= len ? str : str + " ".repeat(len - str.length);
+}
+function formatTable(headers, rows) {
+	const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+	return [
+		headers.map((h, i) => padRight(h, widths[i] ?? h.length)).join("  "),
+		widths.map((w) => "─".repeat(w)).join("──"),
+		...rows.map((row) => row.map((cell, i) => padRight(cell, widths[i] ?? cell.length)).join("  "))
+	].join("\n");
+}
+function statusIcon(pass) {
+	return pass ? pc.green("✓") : pc.red("✗");
+}
+//#endregion
+export { severityColor as a, pc as i, formatPercent as n, statusIcon as o, formatTable as r, formatCount as t };

package/dist/validate-DnVamp3p.mjs

@@ -0,0 +1,155 @@
+import { n as requireInitialized, r as resolveProjectRoot, t as loadProjectContext } from "./context-An3xrvcP.mjs";
+import { a as severityColor, i as pc, t as formatCount } from "./ui-B5mXontH.mjs";
+import { defineCommand } from "citty";
+import { intro, isCancel, log, outro, select, spinner } from "@clack/prompts";
+import { writeContext } from "@contentrain/mcp/core/context";
+import { buildBranchName, createTransaction } from "@contentrain/mcp/git/transaction";
+import { validateProject } from "@contentrain/mcp/core/validator";
+//#region src/commands/validate.ts
+var validate_default = defineCommand({
+	meta: {
+		name: "validate",
+		description: "Validate project content against schemas"
+	},
+	args: {
+		root: {
+			type: "string",
+			description: "Project root path",
+			required: false
+		},
+		fix: {
+			type: "boolean",
+			description: "Auto-fix issues",
+			required: false
+		},
+		interactive: {
+			type: "boolean",
+			description: "Interactive fix mode",
+			required: false
+		},
+		json: {
+			type: "boolean",
+			description: "JSON output for CI",
+			required: false
+		},
+		model: {
+			type: "string",
+			description: "Validate single model",
+			required: false
+		}
+	},
+	async run({ args }) {
+		const projectRoot = await resolveProjectRoot(args.root);
+		requireInitialized(await loadProjectContext(projectRoot));
+		if (!args.json) intro(pc.bold("contentrain validate"));
+		const s = !args.json ? spinner() : null;
+		s?.start("Validating...");
+		let result;
+		if (args.fix) {
+			const { checkBranchHealth } = await import("@contentrain/mcp/git/branch-lifecycle");
+			const health = await checkBranchHealth(projectRoot);
+			if (health.blocked) {
+				s?.stop("Blocked");
+				log.error(health.message);
+				outro("");
+				process.exitCode = 1;
+				return;
+			}
+			const tx = await createTransaction(projectRoot, buildBranchName("fix", "validate"));
+			try {
+				await tx.write(async (wt) => {
+					result = await validateProject(wt, {
+						model: args.model,
+						fix: true
+					});
+					await writeContext(wt, {
+						tool: "contentrain_validate",
+						model: args.model ?? "*"
+					});
+				});
+				await tx.commit("[contentrain] validate: auto-fix");
+				await tx.complete();
+			} finally {
+				await tx.cleanup();
+			}
+		} else result = await validateProject(projectRoot, {
+			model: args.model,
+			fix: false
+		});
+		s?.stop("Validation complete");
+		if (args.json) {
+			process.stdout.write(JSON.stringify(result, null, 2));
+			return;
+		}
+		log.info(pc.bold("Summary"));
+		log.message(`  Models checked:  ${result.summary.models_checked}`);
+		log.message(`  Entries checked: ${result.summary.entries_checked}`);
+		log.message(`  Errors:   ${result.summary.errors > 0 ? pc.red(String(result.summary.errors)) : pc.green("0")}`);
+		log.message(`  Warnings: ${result.summary.warnings > 0 ? pc.yellow(String(result.summary.warnings)) : pc.green("0")}`);
+		log.message(`  Notices:  ${result.summary.notices > 0 ? pc.blue(String(result.summary.notices)) : "0"}`);
+		if (args.fix && result.fixed > 0) log.success(`Fixed ${result.fixed} issue(s)`);
+		if (result.issues.length > 0) {
+			log.info(pc.bold("\nIssues"));
+			for (const issue of result.issues) {
+				const prefix = severityColor(issue.severity)(`[${issue.severity.toUpperCase()}]`);
+				const location = [
+					issue.model,
+					issue.field,
+					issue.entry
+				].filter(Boolean).join(" → ");
+				log.message(`  ${prefix} ${location}: ${issue.message}`);
+			}
+			if (args.interactive && result.issues.some((i) => i.severity === "error" || i.severity === "warning")) {
+				log.info("\n" + pc.bold("Interactive fix mode"));
+				const fixChoice = await select({
+					message: "How would you like to proceed?",
+					options: [{
+						value: "fix-all",
+						label: "Fix all auto-fixable issues"
+					}, {
+						value: "skip",
+						label: "Skip — I'll fix manually"
+					}]
+				});
+				if (!isCancel(fixChoice) && fixChoice === "fix-all") {
+					const fixS = spinner();
+					fixS.start("Fixing issues...");
+					const fixBranch = buildBranchName("fix", "validate");
+					const fixTx = await createTransaction(projectRoot, fixBranch);
+					let fixResult;
+					try {
+						await fixTx.write(async (wt) => {
+							fixResult = await validateProject(wt, {
+								model: args.model,
+								fix: true
+							});
+							await writeContext(wt, {
+								tool: "contentrain_validate",
+								model: args.model ?? "*"
+							});
+						});
+						await fixTx.commit("[contentrain] validate: interactive auto-fix");
+						await fixTx.complete();
+					} finally {
+						await fixTx.cleanup();
+					}
+					fixS.stop(`Fixed ${fixResult.fixed} issue(s)`);
+					const { readConfig } = await import("@contentrain/mcp/core/config");
+					if ((await readConfig(projectRoot))?.workflow === "review") log.info(`Fixes committed to branch ${pc.cyan(fixBranch)}. Run ${pc.cyan("contentrain diff")} to review and merge.`);
+					else {
+						const recheck = await validateProject(projectRoot, { model: args.model });
+						if (recheck.summary.errors === 0) log.success("All errors resolved!");
+						else log.warning(`${formatCount(recheck.summary.errors, "error")} remaining (may need manual fix)`);
+					}
+				}
+			}
+		}
+		if (result.valid) outro(pc.green("Project is valid!"));
+		else {
+			outro(pc.yellow(`${formatCount(result.summary.errors, "error")}, ${formatCount(result.summary.warnings, "warning")}`));
+			if (!args.fix && !args.interactive) log.message(`Run ${pc.cyan("contentrain validate --fix")} to auto-fix.`);
+		}
+	}
+});
+//#endregion
+export { validate_default as default };

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "contentrain",
+  "version": "0.1.0",
+  "license": "MIT",
+  "description": "CLI for Contentrain — AI content governance infrastructure",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/contentrain/contentrain-ai.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/contentrain/contentrain-ai/tree/main/packages/cli",
+  "bugs": {
+    "url": "https://github.com/contentrain/contentrain-ai/issues"
+  },
+  "keywords": [
+    "contentrain",
+    "cli",
+    "mcp",
+    "content-governance",
+    "ai",
+    "i18n",
+    "cms"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "contentrain": "./dist/index.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.10.0",
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "chokidar": "^4.0.0",
+    "citty": "^0.1.0",
+    "consola": "^3.4.0",
+    "crossws": "^0.3.0",
+    "h3": "^1.15.0",
+    "picocolors": "^1.1.0",
+    "simple-git": "^3.27.0",
+    "ws": "^8.18.0",
+    "@contentrain/rules": "0.1.0",
+    "@contentrain/types": "0.1.0",
+    "@contentrain/mcp": "1.0.0",
+    "@contentrain/query": "5.0.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.0",
+    "@types/node": "^22.0.0",
+    "tsdown": "^0.21.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --format esm && cd src/serve-ui && npx vite build",
+    "build:cli-only": "tsdown src/index.ts --format esm",
+    "build:ui-only": "cd src/serve-ui && npx vite build",
+    "dev": "tsdown src/index.ts --format esm --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}