@pracht/cli 1.5.1 → 1.6.0

package/dist/bundle-report-DxTtmipa.mjs

@@ -0,0 +1,218 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { gzipSync } from "node:zlib";
+//#region src/bundle-report.ts
+const SIZE_UNITS = {
+	b: 1,
+	kb: 1024,
+	mb: 1024 * 1024,
+	gb: 1024 * 1024 * 1024
+};
+const SIZE_RE = /^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/;
+/**
+* Parse a size budget value into bytes. Accepts plain numbers (bytes) or
+* size strings like "120kb" / "1mb" (1kb = 1024 bytes).
+*/
+function parseSizeToBytes(value) {
+	if (typeof value === "number") {
+		if (!Number.isFinite(value) || value <= 0) throw new Error(`Invalid size ${JSON.stringify(value)}: expected a positive number of bytes.`);
+		return Math.floor(value);
+	}
+	const match = SIZE_RE.exec(value.trim().toLowerCase());
+	if (!match) throw new Error(`Invalid size ${JSON.stringify(value)}: expected a byte count or a size string like "120kb" or "1mb".`);
+	const amount = Number.parseFloat(match[1]);
+	const bytes = Math.round(amount * SIZE_UNITS[match[2] ?? "b"]);
+	if (bytes <= 0) throw new Error(`Invalid size ${JSON.stringify(value)}: expected a positive size.`);
+	return bytes;
+}
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes}b`;
+	const kb = bytes / 1024;
+	if (kb < 1024) return `${kb.toFixed(1)}kb`;
+	return `${(kb / 1024).toFixed(2)}mb`;
+}
+/** Strip leading `./` and `/` so module paths share one canonical form. */
+function normalizeModulePath(path) {
+	return path.replace(/^\.?\//, "");
+}
+function buildSuffixIndex(manifest) {
+	const index = /* @__PURE__ */ new Map();
+	for (const key of Object.keys(manifest)) {
+		const normalized = normalizeModulePath(key);
+		if (!normalized) continue;
+		if (!index.has(normalized)) index.set(normalized, key);
+		for (let i = normalized.indexOf("/"); i !== -1; i = normalized.indexOf("/", i + 1)) {
+			const suffix = normalized.slice(i + 1);
+			if (suffix && !index.has(suffix)) index.set(suffix, key);
+		}
+	}
+	return index;
+}
+function resolveManifestEntries(manifest, suffixIndex, file) {
+	if (file in manifest) return manifest[file];
+	const resolved = suffixIndex.get(normalizeModulePath(file));
+	return resolved ? manifest[resolved] : [];
+}
+function collectBundleReport({ routes, jsManifest, clientEntryJs, clientDir }) {
+	const suffixIndex = buildSuffixIndex(jsManifest);
+	const chunkCache = /* @__PURE__ */ new Map();
+	function measureChunk(url) {
+		const cached = chunkCache.get(url);
+		if (cached) return cached;
+		const filePath = join(clientDir, url.replace(/^\//, ""));
+		let bytes = 0;
+		let gzipBytes = 0;
+		if (existsSync(filePath)) {
+			const contents = readFileSync(filePath);
+			bytes = contents.byteLength;
+			gzipBytes = gzipSync(contents).byteLength;
+		}
+		const chunk = {
+			url,
+			bytes,
+			gzipBytes
+		};
+		chunkCache.set(url, chunk);
+		return chunk;
+	}
+	const sharedUrls = new Set(clientEntryJs);
+	const sharedChunks = clientEntryJs.map(measureChunk);
+	const sharedBytes = sumBytes(sharedChunks);
+	const sharedGzipBytes = sumGzipBytes(sharedChunks);
+	const reportRoutes = routes.map((route) => {
+		const urls = /* @__PURE__ */ new Set();
+		if (route.shellFile) for (const url of resolveManifestEntries(jsManifest, suffixIndex, route.shellFile)) urls.add(url);
+		for (const url of resolveManifestEntries(jsManifest, suffixIndex, route.file)) urls.add(url);
+		const chunks = [...urls].filter((url) => !sharedUrls.has(url)).map(measureChunk).sort((left, right) => right.gzipBytes - left.gzipBytes);
+		const routeBytes = sumBytes(chunks);
+		const routeGzipBytes = sumGzipBytes(chunks);
+		return {
+			...route.id ? { id: route.id } : {},
+			path: route.path,
+			render: route.render ?? "ssr",
+			chunks,
+			routeBytes,
+			routeGzipBytes,
+			totalBytes: routeBytes + sharedBytes,
+			totalGzipBytes: routeGzipBytes + sharedGzipBytes
+		};
+	});
+	reportRoutes.sort((left, right) => right.totalGzipBytes - left.totalGzipBytes || left.path.localeCompare(right.path));
+	return {
+		shared: {
+			chunks: [...sharedChunks].sort((left, right) => right.gzipBytes - left.gzipBytes),
+			bytes: sharedBytes,
+			gzipBytes: sharedGzipBytes
+		},
+		routes: reportRoutes
+	};
+}
+function sumBytes(chunks) {
+	return chunks.reduce((total, chunk) => total + chunk.bytes, 0);
+}
+function sumGzipBytes(chunks) {
+	return chunks.reduce((total, chunk) => total + chunk.gzipBytes, 0);
+}
+function evaluateBudgets(report, budgets) {
+	const defaultBudget = budgets["*"];
+	const explicitKeys = Object.keys(budgets).filter((key) => key !== "*");
+	const routePaths = new Set(report.routes.map((route) => route.path));
+	const unmatched = explicitKeys.filter((key) => !routePaths.has(key));
+	const results = [];
+	for (const route of report.routes) {
+		const source = route.path in budgets ? route.path : defaultBudget != null ? "*" : null;
+		if (source == null) continue;
+		const budget = budgets[source];
+		const limitBytes = parseSizeToBytes(budget);
+		results.push({
+			path: route.path,
+			render: route.render,
+			budget,
+			source,
+			limitBytes,
+			gzipBytes: route.totalGzipBytes,
+			ok: route.totalGzipBytes <= limitBytes
+		});
+	}
+	return {
+		results,
+		unmatched,
+		ok: results.every((result) => result.ok)
+	};
+}
+function shouldUseColor() {
+	if (process.env.NO_COLOR) return false;
+	return Boolean(process.stdout.isTTY);
+}
+function paint(text, code, color) {
+	return color ? `\u001b[${code}m${text}\u001b[0m` : text;
+}
+function formatBundleReport(report, options = {}) {
+	const color = options.color ?? false;
+	const rows = [];
+	for (const route of report.routes) {
+		rows.push({
+			label: `${route.path} (${route.render})`,
+			raw: "",
+			gzip: "",
+			kind: "header"
+		});
+		for (const chunk of route.chunks) rows.push({
+			label: `  ${chunk.url}`,
+			raw: formatBytes(chunk.bytes),
+			gzip: formatBytes(chunk.gzipBytes),
+			kind: "chunk"
+		});
+		rows.push({
+			label: "  total (incl. shared)",
+			raw: formatBytes(route.totalBytes),
+			gzip: formatBytes(route.totalGzipBytes),
+			kind: "total"
+		});
+	}
+	rows.push({
+		label: "shared entry (all routes)",
+		raw: "",
+		gzip: "",
+		kind: "header"
+	});
+	for (const chunk of report.shared.chunks) rows.push({
+		label: `  ${chunk.url}`,
+		raw: formatBytes(chunk.bytes),
+		gzip: formatBytes(chunk.gzipBytes),
+		kind: "chunk"
+	});
+	rows.push({
+		label: "  total",
+		raw: formatBytes(report.shared.bytes),
+		gzip: formatBytes(report.shared.gzipBytes),
+		kind: "total"
+	});
+	const labelWidth = Math.max(13, ...rows.map((row) => row.label.length));
+	const gzipWidth = Math.max(4, ...rows.map((row) => row.gzip.length));
+	const rawWidth = Math.max(3, ...rows.map((row) => row.raw.length));
+	const lines = [];
+	lines.push(paint(`${"Route / chunk".padEnd(labelWidth)}  ${"Gzip".padStart(gzipWidth)}  ${"Raw".padStart(rawWidth)}`, "1", color));
+	for (const row of rows) {
+		const line = `${row.label.padEnd(labelWidth)}  ${row.gzip.padStart(gzipWidth)}  ${row.raw.padStart(rawWidth)}`;
+		if (row.kind === "header") lines.push(paint(line.trimEnd(), "1", color));
+		else if (row.kind === "total") lines.push(paint(line, "36", color));
+		else lines.push(paint(line, "2", color));
+	}
+	return lines.join("\n");
+}
+function formatBudgetResults(evaluation, options = {}) {
+	const color = options.color ?? false;
+	const lines = [paint("Budgets (gzip client JS)", "1", color)];
+	const pathWidth = Math.max(...evaluation.results.map((result) => result.path.length), 0);
+	for (const result of evaluation.results) {
+		const status = result.ok ? paint("PASS", "32", color) : paint("FAIL", "31", color);
+		const comparison = result.ok ? "<=" : ">";
+		const suffix = result.source === "*" ? " (*)" : "";
+		lines.push(`${status}  ${result.path.padEnd(pathWidth)}  ${formatBytes(result.gzipBytes)} ${comparison} ${formatBytes(result.limitBytes)}${suffix}`);
+	}
+	for (const key of evaluation.unmatched) lines.push(paint(`WARN  budget for ${JSON.stringify(key)} does not match any route.`, "33", color));
+	return lines.join("\n");
+}
+//#endregion
+export { formatBytes as a, formatBundleReport as i, evaluateBudgets as n, shouldUseColor as o, formatBudgetResults as r, collectBundleReport as t };

package/dist/dev-DwAbdNBf.mjs

@@ -0,0 +1,173 @@
+import { t as HTTP_METHODS } from "./index.mjs";
+import { defineCommand } from "citty";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { createServer } from "vite";
+//#region src/app-graph.ts
+const METHOD_ORDER = [...HTTP_METHODS];
+/**
+* Load the resolved app graph (page routes + API routes) from a running Vite
+* dev server. Shared by `pracht inspect` and the `pracht dev` startup banner.
+*/
+async function collectAppGraph(server, root, options = {}) {
+	const serverModule = await server.ssrLoadModule("virtual:pracht/server");
+	return {
+		api: await collectApiRoutes(server, root, serverModule.apiRoutes, options),
+		routes: serializeResolvedRoutes(serverModule.resolvedApp.routes)
+	};
+}
+function serializeResolvedRoutes(routes) {
+	return routes.map((route) => ({
+		file: route.file,
+		id: route.id,
+		loaderFile: route.loaderFile ?? null,
+		middleware: route.middleware,
+		path: route.path,
+		render: route.render ?? null,
+		revalidate: route.revalidate ?? null,
+		shell: route.shell ?? null,
+		shellFile: route.shellFile ?? null
+	}));
+}
+async function collectApiRoutes(server, root, apiRoutes, options = {}) {
+	return Promise.all(apiRoutes.map(async (route) => ({
+		file: route.file,
+		methods: await detectApiMethods(server, root, route.file, options),
+		path: route.path
+	})));
+}
+async function detectApiMethods(server, root, file, options) {
+	const source = readFileSync(resolve(root, `.${file}`), "utf-8");
+	if (options.executeApiModules) try {
+		const module = await server.ssrLoadModule(file);
+		return METHOD_ORDER.filter((method) => typeof module[method] === "function");
+	} catch {}
+	return METHOD_ORDER.filter((method) => new RegExp(`export\\s+(?:async\\s+)?(?:function|const|let|var)\\s+${method}\\b`).test(source));
+}
+//#endregion
+//#region src/dev-banner.ts
+const ANSI = {
+	bold: "1",
+	cyan: "36",
+	dim: "2",
+	green: "32",
+	magenta: "35",
+	yellow: "33"
+};
+const MODE_COLORS = {
+	isg: ANSI.cyan,
+	spa: ANSI.magenta,
+	ssg: ANSI.green,
+	ssr: ANSI.yellow
+};
+/**
+* Format the `pracht dev` startup banner: local URL(s) plus an aligned table
+* of page routes (pattern, render mode, shell, middleware) and API routes.
+*/
+function formatDevBanner(options) {
+	const { apiRoutes, color = false, localUrls, networkUrls = [], routes } = options;
+	const paint = (text, code) => color ? `\u001b[${code}m${text}\u001b[0m` : text;
+	const lines = [];
+	lines.push("");
+	lines.push(`  ${paint("pracht dev", ANSI.bold)}`);
+	lines.push("");
+	for (const url of localUrls) lines.push(`  ${paint("➜", ANSI.green)}  Local:   ${paint(url, `${ANSI.bold};${ANSI.cyan}`)}`);
+	for (const url of networkUrls) lines.push(`  ${paint("➜", ANSI.green)}  Network: ${paint(url, ANSI.cyan)}`);
+	lines.push("");
+	lines.push(`  ${paint(`Routes (${routes.length})`, ANSI.bold)}`);
+	if (routes.length === 0) lines.push("    (none)");
+	else {
+		const rows = routes.map((route) => [
+			route.path,
+			route.render ?? "ssr",
+			route.shell ?? "-",
+			route.middleware.length > 0 ? route.middleware.join(", ") : "-"
+		]);
+		const header = [
+			"ROUTE",
+			"MODE",
+			"SHELL",
+			"MIDDLEWARE"
+		];
+		const widths = columnWidths([header, ...rows]);
+		lines.push(`    ${paint(formatRow(header, widths), ANSI.dim)}`);
+		for (const row of rows) {
+			const [path, mode, shell, middleware] = row;
+			const cells = [
+				path.padEnd(widths[0]),
+				paint(mode.padEnd(widths[1]), MODE_COLORS[mode] ?? ANSI.dim),
+				shell.padEnd(widths[2]),
+				middleware
+			];
+			lines.push(`    ${cells.join("  ")}`.trimEnd());
+		}
+	}
+	lines.push("");
+	lines.push(`  ${paint(`API (${apiRoutes.length})`, ANSI.bold)}`);
+	if (apiRoutes.length === 0) lines.push("    (none)");
+	else {
+		const rows = apiRoutes.map((route) => [route.path, route.methods.length > 0 ? route.methods.join(", ") : "-"]);
+		const header = ["ROUTE", "METHODS"];
+		const widths = columnWidths([header, ...rows]);
+		lines.push(`    ${paint(formatRow(header, widths), ANSI.dim)}`);
+		for (const row of rows) lines.push(`    ${formatRow(row, widths)}`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+/** Respect NO_COLOR (https://no-color.org) and only color TTY output. */
+function supportsColor(env = process.env, isTTY = Boolean(process.stdout.isTTY)) {
+	if (env.NO_COLOR) return false;
+	if (env.FORCE_COLOR) return true;
+	return isTTY;
+}
+function columnWidths(rows) {
+	const widths = [];
+	for (const row of rows) row.forEach((cell, index) => {
+		widths[index] = Math.max(widths[index] ?? 0, cell.length);
+	});
+	return widths;
+}
+function formatRow(cells, widths) {
+	return cells.map((cell, index) => index === cells.length - 1 ? cell : cell.padEnd(widths[index])).join("  ").trimEnd();
+}
+//#endregion
+//#region src/commands/dev.ts
+var dev_default = defineCommand({
+	meta: {
+		name: "dev",
+		description: "Start development server with HMR"
+	},
+	args: { port: {
+		type: "positional",
+		description: "Port number",
+		required: false
+	} },
+	async run({ args }) {
+		const port = parseInt(process.env.PORT || args.port || "3000", 10);
+		const root = process.cwd();
+		const server = await createServer({
+			root,
+			server: { port }
+		});
+		await server.listen();
+		try {
+			const graph = await collectAppGraph(server, root);
+			const urls = server.resolvedUrls ?? {
+				local: [],
+				network: []
+			};
+			console.log(formatDevBanner({
+				apiRoutes: graph.api,
+				color: supportsColor(),
+				localUrls: urls.local,
+				networkUrls: urls.network,
+				routes: graph.routes
+			}));
+		} catch {
+			server.printUrls();
+		}
+	}
+});
+//#endregion
+export { dev_default as default };

package/dist/{doctor-DyOWEA42.mjs → doctor-uALUogtk.mjs}

@@ -1,4 +1,4 @@
-import { t as runDoctor } from "./verification-CSj-ngqk.mjs";
+import { t as runDoctor } from "./verification-5w_FfRtE.mjs";
 import { defineCommand } from "citty";
 //#region src/commands/doctor.ts
 var doctor_default = defineCommand({

package/dist/{generate-DTMte0kd.mjs → generate-BczObays.mjs}

@@ -1,5 +1,6 @@
-import { _ as requireEnum, a as readProjectConfig, c as resolveProjectPath, d as writeGeneratedFile, f as ensureTrailingNewline, g as quote, h as parseCommaList, l as resolveRouteModulePath, m as parseApiMethods, n as displayPath, o as resolveApiModulePath, s as resolvePagesRouteModulePath, t as assertFileExists, u as resolveScopedFile, v as requirePositiveInteger } from "./project-voPTS9UC.mjs";
-import { a as toManifestModulePath, i as insertArrayItem, n as extractRegistryEntries, o as upsertObjectEntry, t as ensureCoreNamedImport } from "./manifest-Bs5hp3gA.mjs";
+import { t as __exportAll } from "./rolldown-runtime-wcPFST8Q.mjs";
+import { _ as requireEnum, a as readProjectConfig, c as resolveProjectPath, d as writeGeneratedFile, f as ensureTrailingNewline, g as quote, h as parseCommaList, l as resolveRouteModulePath, m as parseApiMethods, n as displayPath, o as resolveApiModulePath, s as resolvePagesRouteModulePath, t as assertFileExists, u as resolveScopedFile, v as requirePositiveInteger } from "./project-2EajzTuX.mjs";
+import { a as toManifestModulePath, i as insertArrayItem, n as extractRegistryEntries, o as upsertObjectEntry, t as ensureCoreNamedImport } from "./manifest-nU7P84qF.mjs";
 import { defineCommand } from "citty";
 import { readFileSync, writeFileSync } from "node:fs";
 //#region src/commands/generate-paths.ts
@@ -141,6 +142,15 @@ function buildStaticPathsStub(params) {
 function escapeJsxText(value) {
 	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
+//#endregion
+//#region src/commands/generate.ts
+var generate_exports = /* @__PURE__ */ __exportAll({
+	default: () => generate_default,
+	generateApi: () => generateApi,
+	generateMiddleware: () => generateMiddleware,
+	generateRoute: () => generateRoute,
+	generateShell: () => generateShell
+});
 var generate_default = defineCommand({
 	meta: {
 		name: "generate",
@@ -400,4 +410,4 @@ function generateApi(args, project) {
 	};
 }
 //#endregion
-export { generate_default as default };
+export { generate_exports as a, generateShell as i, generateMiddleware as n, generateRoute as r, generateApi as t };

package/dist/index.mjs

@@ -41,13 +41,15 @@ runMain(defineCommand({
 		description: "The pracht CLI"
 	},
 	subCommands: {
-		build: () => import("./build-B7_6RUBf.mjs").then((m) => m.default),
-		dev: () => import("./dev-BCFe3g38.mjs").then((m) => m.default),
-		doctor: () => import("./doctor-DyOWEA42.mjs").then((m) => m.default),
-		generate: () => import("./generate-DTMte0kd.mjs").then((m) => m.default),
-		inspect: () => import("./inspect-WF08uLOl.mjs").then((m) => m.default),
-		typegen: () => import("./typegen-Bl4fYQIy.mjs").then((m) => m.default),
-		verify: () => import("./verify-FwVbdlxh.mjs").then((m) => m.default)
+		build: () => import("./build-CGzTcST3.mjs").then((m) => m.default),
+		dev: () => import("./dev-DwAbdNBf.mjs").then((m) => m.default),
+		doctor: () => import("./doctor-uALUogtk.mjs").then((m) => m.default),
+		generate: () => import("./generate-BczObays.mjs").then((n) => n.a).then((m) => m.default),
+		inspect: () => import("./inspect-Bxt-6Lmc.mjs").then((n) => n.t).then((m) => m.default),
+		mcp: () => import("./mcp-Dv9EeFtp.mjs").then((m) => m.default),
+		preview: () => import("./preview-B0-hgVfI.mjs").then((m) => m.default),
+		typegen: () => import("./typegen-KYYNjYDt.mjs").then((m) => m.default),
+		verify: () => import("./verify-B_HUuyEQ.mjs").then((m) => m.default)
 	}
 }));
 //#endregion

package/dist/{inspect-WF08uLOl.mjs → inspect-Bxt-6Lmc.mjs}

@@ -1,18 +1,22 @@
-import { t as HTTP_METHODS } from "./index.mjs";
-import { t as readClientBuildAssets } from "./build-metadata-BOChHO8g.mjs";
-import { a as readProjectConfig, c as resolveProjectPath, p as handleCliError } from "./project-voPTS9UC.mjs";
+import { t as __exportAll } from "./rolldown-runtime-wcPFST8Q.mjs";
+import { t as readClientBuildAssets } from "./build-metadata-DyMzBVtV.mjs";
+import { a as readProjectConfig, c as resolveProjectPath, p as handleCliError } from "./project-2EajzTuX.mjs";
 import { defineCommand } from "citty";
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { createServer } from "vite";
+import { serializeApiRoutes, serializeAppRoutes } from "@pracht/core";
 //#region src/commands/inspect.ts
+var inspect_exports = /* @__PURE__ */ __exportAll({
+	default: () => inspect_default,
+	runInspect: () => runInspect
+});
 const INSPECT_TARGETS = new Set([
 	"routes",
 	"api",
 	"build",
 	"all"
 ]);
-const METHOD_ORDER = [...HTTP_METHODS];
 var inspect_default = defineCommand({
 	meta: {
 		name: "inspect",
@@ -55,12 +59,11 @@ async function runInspect(root, { target = "all" } = {}) {
 	try {
 		const serverModule = await server.ssrLoadModule("virtual:pracht/server");
 		const report = { mode: project.mode };
-		if (target === "routes" || target === "all") report.routes = serializeRoutes(serverModule.resolvedApp.routes);
-		if (target === "api" || target === "all") report.api = await Promise.all(serverModule.apiRoutes.map(async (route) => ({
-			file: route.file,
-			methods: await detectApiMethods(server, root, route.file),
-			path: route.path
-		})));
+		if (target === "routes" || target === "all") report.routes = serializeAppRoutes(serverModule.resolvedApp.routes);
+		if (target === "api" || target === "all") report.api = await serializeApiRoutes(serverModule.apiRoutes, {
+			loadModule: (file) => server.ssrLoadModule(file),
+			readSource: (file) => readFileSync(resolve(root, `.${file}`), "utf-8")
+		});
 		if (target === "build" || target === "all") {
 			const buildAssets = readClientBuildAssets(root);
 			report.build = {
@@ -75,28 +78,6 @@ async function runInspect(root, { target = "all" } = {}) {
 		await server.close();
 	}
 }
-function serializeRoutes(routes) {
-	return routes.map((route) => ({
-		file: route.file,
-		id: route.id,
-		loaderFile: route.loaderFile ?? null,
-		middleware: route.middleware,
-		path: route.path,
-		render: route.render ?? null,
-		revalidate: route.revalidate ?? null,
-		shell: route.shell ?? null,
-		shellFile: route.shellFile ?? null
-	}));
-}
-async function detectApiMethods(server, root, file) {
-	const source = readFileSync(resolve(root, `.${file}`), "utf-8");
-	try {
-		const module = await server.ssrLoadModule(file);
-		return METHOD_ORDER.filter((method) => typeof module[method] === "function");
-	} catch {
-		return METHOD_ORDER.filter((method) => new RegExp(`export\\s+(?:async\\s+)?(?:function|const|let|var)\\s+${method}\\b`).test(source));
-	}
-}
 function printInspectReport(report) {
 	console.log(`Pracht inspect (${report.mode} mode)`);
 	if (report.routes) {
@@ -120,4 +101,4 @@ function printInspectReport(report) {
 	}
 }
 //#endregion
-export { inspect_default as default, runInspect };
+export { runInspect as n, inspect_exports as t };

package/dist/mcp-Dv9EeFtp.mjs

@@ -0,0 +1,154 @@
+import { r as VERSION } from "./index.mjs";
+import { a as readProjectConfig } from "./project-2EajzTuX.mjs";
+import { n as runVerification, t as runDoctor } from "./verification-5w_FfRtE.mjs";
+import { i as generateShell, n as generateMiddleware, r as generateRoute, t as generateApi } from "./generate-BczObays.mjs";
+import { n as runInspect } from "./inspect-Bxt-6Lmc.mjs";
+import { defineCommand } from "citty";
+import { resolve } from "node:path";
+import { format } from "node:util";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+//#region src/mcp-server.ts
+const cwdInput = { cwd: z.string().optional().describe("Absolute path to the pracht app root. Defaults to the server's working directory.") };
+function createPrachtMcpServer() {
+	const server = new McpServer({
+		name: "pracht",
+		version: VERSION
+	});
+	server.registerTool("inspect_routes", {
+		description: "Inspect the resolved page-route graph of a pracht app: path, id, render mode, shell, middleware, loader file. Same payload as `pracht inspect routes --json`.",
+		inputSchema: { ...cwdInput }
+	}, guard(({ cwd }) => runInspect(resolveCwd(cwd), { target: "routes" })));
+	server.registerTool("inspect_api", {
+		description: "Inspect the resolved API routes of a pracht app: endpoint path, source file, exported HTTP methods. Same payload as `pracht inspect api --json`.",
+		inputSchema: { ...cwdInput }
+	}, guard(({ cwd }) => runInspect(resolveCwd(cwd), { target: "api" })));
+	server.registerTool("inspect_build", {
+		description: "Inspect build metadata of a pracht app: adapter target, client entry URL, CSS/JS manifests. Requires a prior `pracht build`. Same payload as `pracht inspect build --json`.",
+		inputSchema: { ...cwdInput }
+	}, guard(({ cwd }) => runInspect(resolveCwd(cwd), { target: "build" })));
+	server.registerTool("doctor", {
+		description: "Validate pracht app wiring (config, manifest references, adapter dependency). Same payload as `pracht doctor --json`.",
+		inputSchema: { ...cwdInput }
+	}, guard(({ cwd }) => runDoctor(resolveCwd(cwd))));
+	server.registerTool("verify", {
+		description: "Run fast framework-aware verification checks on a pracht app. Same payload as `pracht verify --json`.",
+		inputSchema: {
+			...cwdInput,
+			changed: z.boolean().optional().describe("Only check files changed according to git (maps to --changed).")
+		}
+	}, guard(({ changed, cwd }) => runVerification(resolveCwd(cwd), { changed: Boolean(changed) })));
+	server.registerTool("generate_route", {
+		description: "Scaffold a pracht route module and wire it into the app (manifest apps update src/routes.ts; pages apps create the page file). Returns the files created and updated.",
+		inputSchema: {
+			...cwdInput,
+			path: z.string().describe("Route path, e.g. /dashboard or /blog/:slug"),
+			render: z.enum([
+				"spa",
+				"ssr",
+				"ssg",
+				"isg"
+			]).optional().describe("Render mode (defaults to ssr)."),
+			shell: z.string().optional().describe("Registered shell name (manifest apps only)."),
+			middleware: z.array(z.string()).optional().describe("Registered middleware names (manifest apps only)."),
+			loader: z.boolean().optional().describe("Include a loader export."),
+			errorBoundary: z.boolean().optional().describe("Include an error boundary export."),
+			staticPaths: z.boolean().optional().describe("Include a getStaticPaths export."),
+			title: z.string().optional().describe("Page title used in the head export."),
+			revalidate: z.number().int().positive().optional().describe("ISG revalidation window in seconds (isg render mode only).")
+		}
+	}, guard((input) => {
+		const project = readProjectConfig(resolveCwd(input.cwd));
+		return generateRoute({
+			"error-boundary": input.errorBoundary,
+			loader: input.loader,
+			middleware: input.middleware?.join(","),
+			path: input.path,
+			render: input.render,
+			revalidate: input.revalidate === void 0 ? void 0 : String(input.revalidate),
+			shell: input.shell,
+			"static-paths": input.staticPaths,
+			title: input.title
+		}, project);
+	}));
+	server.registerTool("generate_shell", {
+		description: "Scaffold a pracht shell component and register it in the app manifest (manifest apps only). Returns the files created and updated.",
+		inputSchema: {
+			...cwdInput,
+			name: z.string().describe("Shell name, e.g. app or public")
+		}
+	}, guard(({ cwd, name }) => {
+		return generateShell(name, readProjectConfig(resolveCwd(cwd)));
+	}));
+	server.registerTool("generate_middleware", {
+		description: "Scaffold a pracht middleware function and register it in the app manifest (manifest apps only). Returns the files created and updated.",
+		inputSchema: {
+			...cwdInput,
+			name: z.string().describe("Middleware name, e.g. auth")
+		}
+	}, guard(({ cwd, name }) => {
+		return generateMiddleware(name, readProjectConfig(resolveCwd(cwd)));
+	}));
+	server.registerTool("generate_api", {
+		description: "Scaffold a pracht API route with typed HTTP method handlers. Returns the files created and updated.",
+		inputSchema: {
+			...cwdInput,
+			path: z.string().describe("API endpoint path, e.g. /health or /users/:id"),
+			methods: z.array(z.string()).optional().describe("HTTP methods to scaffold, e.g. [\"GET\", \"POST\"] (defaults to GET).")
+		}
+	}, guard(({ cwd, methods, path }) => {
+		const project = readProjectConfig(resolveCwd(cwd));
+		return generateApi({
+			methods: methods?.join(","),
+			path
+		}, project);
+	}));
+	return server;
+}
+function resolveCwd(cwd) {
+	return resolve(cwd ?? process.cwd());
+}
+function guard(handler) {
+	return async (input) => {
+		try {
+			const result = await handler(input);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: error instanceof Error ? error.message : String(error)
+				}],
+				isError: true
+			};
+		}
+	};
+}
+//#endregion
+//#region src/commands/mcp.ts
+var mcp_default = defineCommand({
+	meta: {
+		name: "mcp",
+		description: "Start a Model Context Protocol server on stdio"
+	},
+	async run() {
+		for (const method of [
+			"debug",
+			"error",
+			"info",
+			"log",
+			"trace",
+			"warn"
+		]) console[method] = (...args) => {
+			process.stderr.write(`${format(...args)}\n`);
+		};
+		await createPrachtMcpServer().connect(new StdioServerTransport());
+		process.stderr.write("pracht MCP server listening on stdio\n");
+	}
+});
+//#endregion
+export { mcp_default as default };