contentrain 0.1.0

package/dist/server-DW0KXB0T.mjs

@@ -0,0 +1,607 @@
+import { simpleGit } from "simple-git";
+import { join } from "node:path";
+import { readFile, unlink, writeFile } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import { createServer } from "@contentrain/mcp/server";
+import { createApp, createError, createRouter, defineEventHandler, getQuery, getRouterParam, readBody, toNodeListener } from "h3";
+import { WebSocketServer } from "ws";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { watch as watch$1 } from "chokidar";
+//#region src/serve/server.ts
+function apiError(error) {
+	if (error && typeof error === "object" && "statusCode" in error) {
+		const e = error;
+		return {
+			statusCode: e.statusCode,
+			error: e.message ?? "Unknown error"
+		};
+	}
+	return {
+		statusCode: 500,
+		error: error instanceof Error ? error.message : String(error)
+	};
+}
+async function createServeApp(options) {
+	const { projectRoot, uiDir } = options;
+	const crDir = join(projectRoot, ".contentrain");
+	function getDefaultBranch() {
+		try {
+			const raw = readFileSync(join(crDir, "config.json"), "utf-8");
+			const cfg = JSON.parse(raw);
+			if (cfg?.repository?.default_branch) return cfg.repository.default_branch;
+		} catch {}
+		return "main";
+	}
+	const mcpServer = createServer(projectRoot);
+	const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+	const mcpClient = new Client({
+		name: "serve-client",
+		version: "1.0.0"
+	});
+	await Promise.all([mcpClient.connect(clientTransport), mcpServer.connect(serverTransport)]);
+	async function callTool(name, args = {}) {
+		const result = await mcpClient.callTool({
+			name,
+			arguments: args
+		});
+		const textContent = result.content.find((c) => c.type === "text");
+		if (!textContent || !("text" in textContent)) throw createError({
+			statusCode: 500,
+			message: `Tool ${name} returned no text content`
+		});
+		const parsed = JSON.parse(textContent.text);
+		if (result.isError) throw createError({
+			statusCode: 422,
+			message: typeof parsed === "object" && parsed?.error ? parsed.error : textContent.text
+		});
+		return parsed;
+	}
+	const app = createApp({ onError: (error, event) => {
+		if (event.path.startsWith("/api/")) {
+			const { statusCode, error: message } = apiError(error);
+			event.node.res.statusCode = statusCode;
+			event.node.res.setHeader("Content-Type", "application/json");
+			if (!event.node.res.writableEnded) event.node.res.end(JSON.stringify({
+				statusCode,
+				error: message
+			}));
+		}
+	} });
+	const router = createRouter();
+	const wss = new WebSocketServer({ noServer: true });
+	const wsClients = /* @__PURE__ */ new Set();
+	function broadcast(event) {
+		const data = JSON.stringify(event);
+		for (const client of wsClients) if (client.readyState === 1) client.send(data);
+	}
+	wss.on("connection", (ws) => {
+		wsClients.add(ws);
+		ws.send(JSON.stringify({ type: "connected" }));
+		ws.on("close", () => {
+			wsClients.delete(ws);
+		});
+		ws.on("error", () => {
+			wsClients.delete(ws);
+		});
+	});
+	function handleUpgrade(req, socket, head) {
+		if (req.url !== "/ws") {
+			socket.destroy();
+			return;
+		}
+		wss.handleUpgrade(req, socket, head, (ws) => {
+			wss.emit("connection", ws, req);
+		});
+	}
+	if (existsSync(crDir)) {
+		let debounceTimer = null;
+		const pendingEvents = [];
+		const watcher = watch$1(crDir, {
+			ignoreInitial: true,
+			ignored: ["**/node_modules/**", "**/.git/**"],
+			depth: 4
+		});
+		function flush() {
+			if (pendingEvents.length === 0) return;
+			const events = [...pendingEvents];
+			pendingEvents.length = 0;
+			for (const event of events) broadcast(event);
+		}
+		watcher.on("all", (_eventType, filePath) => {
+			const rel = filePath.replace(crDir, "").replace(/^\//, "");
+			let event;
+			if (rel === "config.json") event = { type: "config:changed" };
+			else if (rel === "context.json") {
+				let context = null;
+				try {
+					const raw = readFileSync(join(crDir, "context.json"), "utf-8");
+					context = JSON.parse(raw);
+				} catch {}
+				event = {
+					type: "context:changed",
+					context
+				};
+			} else if (rel === "normalize-plan.json") event = { type: "normalize:plan-updated" };
+			else if (rel.startsWith("models/")) event = {
+				type: "model:changed",
+				modelId: rel.replace("models/", "").replace(".json", "")
+			};
+			else if (rel.startsWith("content/")) {
+				const parts = rel.replace("content/", "").split("/");
+				event = {
+					type: "content:changed",
+					modelId: parts[1],
+					locale: parts[2]?.replace(".json", "")
+				};
+			} else return;
+			pendingEvents.push(event);
+			if (debounceTimer) clearTimeout(debounceTimer);
+			debounceTimer = setTimeout(flush, 300);
+		});
+	}
+	router.add("/api/status", defineEventHandler(async () => {
+		return await callTool("contentrain_status");
+	}));
+	router.add("/api/describe/:modelId", defineEventHandler(async (event) => {
+		return await callTool("contentrain_describe", {
+			model: getRouterParam(event, "modelId"),
+			include_sample: true
+		});
+	}));
+	router.add("/api/content/:modelId", defineEventHandler(async (event) => {
+		const modelId = getRouterParam(event, "modelId");
+		const query = getQuery(event);
+		return await callTool("contentrain_content_list", {
+			model: modelId,
+			locale: query["locale"],
+			limit: query["limit"] ? Number(query["limit"]) : void 0,
+			offset: query["offset"] ? Number(query["offset"]) : void 0
+		});
+	}));
+	router.add("/api/content/:modelId/:entryId", defineEventHandler(async (event) => {
+		const modelId = getRouterParam(event, "modelId");
+		const entryId = getRouterParam(event, "entryId");
+		return await callTool("contentrain_content_list", {
+			model: modelId,
+			locale: getQuery(event)["locale"],
+			filter: { id: entryId },
+			limit: 1
+		});
+	}));
+	router.add("/api/content/:modelId/:entryId/fix", defineEventHandler(async (event) => {
+		if (event.method !== "POST") throw createError({
+			statusCode: 405,
+			message: "Method not allowed"
+		});
+		const modelId = getRouterParam(event, "modelId");
+		const entryId = getRouterParam(event, "entryId");
+		const body = await readBody(event);
+		const result = await callTool("contentrain_content_save", {
+			model: modelId,
+			entries: [{
+				id: entryId,
+				locale: body.locale,
+				data: body.data
+			}]
+		});
+		broadcast({ type: "validation:updated" });
+		const git = result?.git;
+		if (git?.branch && git?.action === "pending-review") broadcast({
+			type: "branch:created",
+			branch: git.branch
+		});
+		return result;
+	}));
+	router.add("/api/validate", defineEventHandler(async (event) => {
+		const query = getQuery(event);
+		return await callTool("contentrain_validate", {
+			model: query["model"],
+			fix: query["fix"] === "true"
+		});
+	}));
+	router.add("/api/branches", defineEventHandler(async () => {
+		const branches = await simpleGit(projectRoot).branchLocal();
+		const crBranches = branches.all.filter((b) => b.startsWith("contentrain/")).map((b) => ({
+			name: b,
+			current: b === branches.current
+		}));
+		return {
+			branches: crBranches,
+			total: crBranches.length
+		};
+	}));
+	router.add("/api/branches/diff", defineEventHandler(async (event) => {
+		const branchName = getQuery(event)["name"];
+		if (!branchName?.startsWith("contentrain/")) throw createError({
+			statusCode: 400,
+			message: "Invalid branch name"
+		});
+		const git = simpleGit(projectRoot);
+		const defaultBranch = getDefaultBranch();
+		return {
+			branch: branchName,
+			base: defaultBranch,
+			stat: await git.diff([`${defaultBranch}...${branchName}`, "--stat"]),
+			diff: await git.diff([`${defaultBranch}...${branchName}`])
+		};
+	}));
+	router.add("/api/branches/approve", defineEventHandler(async (event) => {
+		if (event.method !== "POST") throw createError({
+			statusCode: 405,
+			message: "Method not allowed"
+		});
+		const branchName = (await readBody(event)).branch;
+		if (!branchName?.startsWith("contentrain/")) throw createError({
+			statusCode: 400,
+			message: "Invalid branch name"
+		});
+		const git = simpleGit(projectRoot);
+		const baseBranch = getDefaultBranch();
+		await git.checkout(baseBranch);
+		await git.merge([
+			branchName,
+			"--no-edit",
+			"-X",
+			"theirs"
+		]);
+		await git.deleteLocalBranch(branchName, true);
+		broadcast({
+			type: "branch:merged",
+			branch: branchName
+		});
+		return {
+			status: "merged",
+			branch: branchName,
+			into: baseBranch
+		};
+	}));
+	router.add("/api/branches/reject", defineEventHandler(async (event) => {
+		if (event.method !== "POST") throw createError({
+			statusCode: 405,
+			message: "Method not allowed"
+		});
+		const branchName = (await readBody(event)).branch;
+		if (!branchName?.startsWith("contentrain/")) throw createError({
+			statusCode: 400,
+			message: "Invalid branch name"
+		});
+		await simpleGit(projectRoot).deleteLocalBranch(branchName, true);
+		return {
+			status: "deleted",
+			branch: branchName
+		};
+	}));
+	router.add("/api/history", defineEventHandler(async (event) => {
+		const query = getQuery(event);
+		const limit = Number(query["limit"]) || 50;
+		const entries = (await simpleGit(projectRoot).log({
+			maxCount: limit * 2,
+			format: {
+				hash: "%h",
+				fullHash: "%H",
+				message: "%s",
+				author: "%an",
+				email: "%ae",
+				date: "%aI",
+				relativeDate: "%ar"
+			}
+		})).all.filter((c) => {
+			const msg = c.message ?? "";
+			return msg.startsWith("[contentrain]") || msg.startsWith("Merge branch 'contentrain/") || msg.includes("contentrain");
+		}).slice(0, limit).map((c) => {
+			const msg = c.message ?? "";
+			let type = "other";
+			let target = "";
+			if (msg.startsWith("[contentrain] created:")) {
+				type = "model_create";
+				target = msg.replace("[contentrain] created: ", "");
+			} else if (msg.startsWith("[contentrain] updated:")) {
+				type = "model_update";
+				target = msg.replace("[contentrain] updated: ", "");
+			} else if (msg.startsWith("[contentrain] content:")) {
+				type = "content_save";
+				target = msg.replace("[contentrain] content: ", "");
+			} else if (msg.startsWith("[contentrain] deleted:")) {
+				type = "delete";
+				target = msg.replace("[contentrain] deleted: ", "");
+			} else if (msg.startsWith("[contentrain] update context")) type = "context_update";
+			else if (msg.startsWith("Merge branch 'contentrain/")) {
+				type = "merge";
+				target = msg.replace("Merge branch '", "").replace("'", "");
+			} else if (msg.startsWith("[contentrain]")) {
+				type = "operation";
+				target = msg.replace("[contentrain] ", "");
+			}
+			return {
+				hash: c.hash,
+				message: msg,
+				type,
+				target,
+				author: c.author,
+				date: c.date,
+				relativeDate: c.relativeDate
+			};
+		});
+		return {
+			entries,
+			total: entries.length
+		};
+	}));
+	router.add("/api/context", defineEventHandler(async () => {
+		const contextPath = join(crDir, "context.json");
+		if (!existsSync(contextPath)) return {
+			lastOperation: null,
+			stats: null
+		};
+		const raw = await readFile(contextPath, "utf-8");
+		return JSON.parse(raw);
+	}));
+	router.add("/api/tree", defineEventHandler(async (event) => {
+		const extensions = (getQuery(event)["ext"] ?? ".vue,.tsx,.jsx,.ts,.js,.astro,.svelte").split(",");
+		const { readdirSync } = await import("node:fs");
+		const ignoreDirs = new Set([
+			"node_modules",
+			".git",
+			"dist",
+			".tmp",
+			".agents",
+			".contentrain",
+			".cache",
+			".claude",
+			".histoire",
+			"serve-ui"
+		]);
+		function buildTree(dirPath, relativePath, depth) {
+			if (depth > 5) return null;
+			const name = relativePath.split("/").pop() ?? relativePath;
+			if (ignoreDirs.has(name)) return null;
+			try {
+				const entries = readdirSync(dirPath, { withFileTypes: true });
+				const children = [];
+				let fileCount = 0;
+				for (const entry of entries) {
+					if (entry.name.startsWith(".") && depth > 0) continue;
+					const childRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+					const childFull = join(dirPath, entry.name);
+					if (entry.isDirectory()) {
+						const sub = buildTree(childFull, childRelative, depth + 1);
+						if (sub && (sub.fileCount ?? 0) > 0) children.push(sub);
+					} else if (entry.isFile()) {
+						const ext = "." + entry.name.split(".").pop();
+						if (extensions.includes(ext)) {
+							children.push({
+								name: entry.name,
+								path: childRelative,
+								type: "file"
+							});
+							fileCount++;
+						}
+					}
+				}
+				for (const child of children) if (child.type === "dir") fileCount += child.fileCount ?? 0;
+				if (fileCount === 0) return null;
+				return {
+					name,
+					path: relativePath || ".",
+					type: "dir",
+					children: children.toSorted((a, b) => {
+						if (a.type !== b.type) return a.type === "dir" ? -1 : 1;
+						return a.name.localeCompare(b.name);
+					}),
+					fileCount
+				};
+			} catch {
+				return null;
+			}
+		}
+		return { tree: buildTree(projectRoot, "", 0)?.children ?? [] };
+	}));
+	router.add("/api/normalize/scan", defineEventHandler(async (event) => {
+		const query = getQuery(event);
+		const mode = query["mode"] ?? "summary";
+		const limit = Number(query["limit"]) || 30;
+		const offset = Number(query["offset"]) || 0;
+		const paths = query["paths"] ? query["paths"].split(",") : void 0;
+		return await callTool("contentrain_scan", {
+			mode,
+			limit,
+			offset,
+			...paths ? { paths } : {}
+		});
+	}));
+	router.add("/api/normalize/results", defineEventHandler(async () => {
+		let lastNormalize = null;
+		try {
+			const raw = readFileSync(join(crDir, "context.json"), "utf-8");
+			const op = JSON.parse(raw)?.lastOperation;
+			if (op?.tool === "contentrain_scan" || op?.tool === "contentrain_apply") lastNormalize = op;
+		} catch {}
+		const branches = (await simpleGit(projectRoot).branchLocal()).all.filter((b) => b.startsWith("contentrain/normalize/")).map((b) => ({ name: b }));
+		return {
+			lastOperation: lastNormalize,
+			pendingBranches: branches
+		};
+	}));
+	router.add("/api/normalize/plan", defineEventHandler(async () => {
+		const planPath = join(crDir, "normalize-plan.json");
+		if (!existsSync(planPath)) return { plan: null };
+		try {
+			const raw = await readFile(planPath, "utf-8");
+			return { plan: JSON.parse(raw) };
+		} catch {
+			return { plan: null };
+		}
+	}));
+	router.add("/api/normalize/plan/reject", defineEventHandler(async (event) => {
+		if (event.method !== "DELETE" && event.method !== "POST") throw createError({
+			statusCode: 405,
+			message: "Method not allowed"
+		});
+		const planPath = join(crDir, "normalize-plan.json");
+		if (existsSync(planPath)) await unlink(planPath);
+		broadcast({ type: "normalize:plan-updated" });
+		return { status: "rejected" };
+	}));
+	router.add("/api/normalize/plan/approve", defineEventHandler(async (event) => {
+		if (event.method !== "POST") throw createError({
+			statusCode: 405,
+			message: "Method not allowed"
+		});
+		const planPath = join(crDir, "normalize-plan.json");
+		if (!existsSync(planPath)) throw createError({
+			statusCode: 404,
+			message: "No normalize plan found"
+		});
+		const raw = await readFile(planPath, "utf-8");
+		const plan = JSON.parse(raw);
+		const selectedModels = (await readBody(event))?.models;
+		plan.status = "approved";
+		plan.approved_at = (/* @__PURE__ */ new Date()).toISOString();
+		if (selectedModels) plan.approved_models = selectedModels;
+		await writeFile(planPath, JSON.stringify(plan, null, 2) + "\n", "utf-8");
+		const modelIds = selectedModels ?? plan.models?.map((m) => m.id) ?? [];
+		const modelMap = new Map((plan.models ?? []).map((m) => [m.id, m]));
+		const groupedByModel = /* @__PURE__ */ new Map();
+		for (const ext of plan.extractions ?? []) {
+			if (!modelIds.includes(ext.model)) continue;
+			const entries = groupedByModel.get(ext.model) ?? [];
+			entries.push({
+				locale: ext.locale,
+				data: { [ext.field]: ext.value },
+				source: {
+					file: ext.file,
+					line: ext.line,
+					value: ext.value
+				}
+			});
+			groupedByModel.set(ext.model, entries);
+		}
+		const applyExtractions = [];
+		for (const [modelId, entries] of groupedByModel) {
+			const model = modelMap.get(modelId);
+			applyExtractions.push({
+				model: modelId,
+				kind: model?.kind ?? "collection",
+				domain: model?.domain ?? "default",
+				i18n: model?.i18n,
+				fields: model?.fields,
+				entries
+			});
+		}
+		const result = await callTool("contentrain_apply", {
+			mode: "extract",
+			dry_run: false,
+			extractions: applyExtractions
+		});
+		if (existsSync(planPath)) await unlink(planPath);
+		broadcast({ type: "normalize:plan-updated" });
+		return result;
+	}));
+	router.add("/api/normalize/apply", defineEventHandler(async (event) => {
+		if (event.method !== "POST") throw createError({
+			statusCode: 405,
+			message: "Method not allowed"
+		});
+		return await callTool("contentrain_apply", await readBody(event));
+	}));
+	router.add("/api/normalize/approve", defineEventHandler(async (event) => {
+		if (event.method !== "POST") throw createError({
+			statusCode: 405,
+			message: "Method not allowed"
+		});
+		const branchName = (await readBody(event)).branch;
+		if (!branchName?.startsWith("contentrain/")) throw createError({
+			statusCode: 400,
+			message: "Invalid branch name"
+		});
+		const git = simpleGit(projectRoot);
+		const currentBranch = (await git.branchLocal()).current;
+		await git.merge([branchName]);
+		await git.deleteLocalBranch(branchName, true);
+		broadcast({
+			type: "branch:merged",
+			branch: branchName
+		});
+		return {
+			status: "merged",
+			branch: branchName,
+			into: currentBranch
+		};
+	}));
+	router.add("/api/normalize/sources", defineEventHandler(async () => {
+		const sourcesPath = join(crDir, "normalize-sources.json");
+		if (!existsSync(sourcesPath)) return { sources: null };
+		try {
+			const raw = await readFile(sourcesPath, "utf-8");
+			return { sources: JSON.parse(raw) };
+		} catch {
+			return { sources: null };
+		}
+	}));
+	router.add("/api/normalize/file-context", defineEventHandler(async (event) => {
+		const query = getQuery(event);
+		const filePath = query["file"];
+		const line = Number(query["line"]) || 1;
+		const range = Number(query["range"]) || 5;
+		if (!filePath || filePath.includes("..") || filePath.startsWith("/")) throw createError({
+			statusCode: 400,
+			message: "Invalid file path"
+		});
+		const fullPath = join(projectRoot, filePath);
+		if (!existsSync(fullPath)) throw createError({
+			statusCode: 404,
+			message: "File not found"
+		});
+		const allLines = (await readFile(fullPath, "utf-8")).split("\n");
+		const startLine = Math.max(1, line - range);
+		const endLine = Math.min(allLines.length, line + range);
+		const lines = [];
+		for (let i = startLine; i <= endLine; i++) lines.push({
+			num: i,
+			content: allLines[i - 1] ?? ""
+		});
+		return {
+			file: filePath,
+			lines,
+			highlight: line,
+			totalLines: allLines.length
+		};
+	}));
+	const MIME_TYPES = {
+		html: "text/html",
+		js: "application/javascript",
+		css: "text/css",
+		json: "application/json",
+		svg: "image/svg+xml",
+		png: "image/png",
+		jpg: "image/jpeg",
+		ico: "image/x-icon",
+		woff2: "font/woff2",
+		woff: "font/woff",
+		ttf: "font/ttf"
+	};
+	function getMimeType(filePath) {
+		return MIME_TYPES[filePath.split(".").pop()?.toLowerCase() ?? ""] ?? "application/octet-stream";
+	}
+	if (existsSync(uiDir)) {
+		const { statSync } = await import("node:fs");
+		app.use(defineEventHandler(async (event) => {
+			if (event.path.startsWith("/api/") || event.path === "/ws") return;
+			let filePath = join(uiDir, event.path === "/" ? "index.html" : event.path);
+			if (!existsSync(filePath) || statSync(filePath).isDirectory()) filePath = join(uiDir, "index.html");
+			const content = await readFile(filePath);
+			event.node.res.setHeader("Content-Type", getMimeType(filePath));
+			event.node.res.setHeader("Content-Length", content.length);
+			return content;
+		}));
+	}
+	app.use(router);
+	return {
+		app,
+		handleUpgrade,
+		toNodeListener: () => toNodeListener(app)
+	};
+}
+//#endregion
+export { createServeApp };