@pracht/cli 1.1.4 → 1.2.0

package/dist/project-DydjqBoS.mjs

@@ -0,0 +1,155 @@
+import { n as PROJECT_DEFAULTS, t as HTTP_METHODS } from "./index.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, relative, resolve } from "node:path";
+//#region src/utils.ts
+function quote(value) {
+	return JSON.stringify(value);
+}
+function ensureTrailingNewline(value) {
+	return value.endsWith("\n") ? value : `${value}\n`;
+}
+function parseCommaList(value) {
+	if (!value || typeof value === "boolean") return [];
+	return (Array.isArray(value) ? value : [value]).flatMap((entry) => String(entry).split(",")).map((entry) => entry.trim()).filter(Boolean);
+}
+function parseApiMethods(value) {
+	const methods = parseCommaList(value);
+	const normalized = methods.length === 0 ? ["GET"] : methods.map((entry) => entry.toUpperCase());
+	for (const method of normalized) if (!HTTP_METHODS.has(method)) throw new Error(`Unsupported HTTP method "${method}".`);
+	return [...new Set(normalized)];
+}
+function requireEnum(value, key, allowed, fallback) {
+	const val = value ?? fallback;
+	if (!allowed.includes(val)) throw new Error(`Invalid value for --${key}. Expected one of ${allowed.join(", ")}.`);
+	return val;
+}
+function requirePositiveInteger(value, key, fallback) {
+	const parsed = value == null ? fallback : Number.parseInt(value, 10);
+	if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(`--${key} must be a positive integer.`);
+	return parsed;
+}
+function handleCliError(error, { json }) {
+	const message = error instanceof Error ? error.message : String(error);
+	if (json) console.error(JSON.stringify({
+		ok: false,
+		error: message
+	}, null, 2));
+	else {
+		console.error(message);
+		if (error instanceof Error && error.stack && process.env.DEBUG) console.error(error.stack);
+	}
+	process.exit(1);
+}
+//#endregion
+//#region src/project.ts
+function readProjectConfig(root) {
+	const configFile = findConfigFile(root);
+	const rawConfig = configFile ? readFileSync(configFile, "utf-8") : "";
+	const config = {
+		...PROJECT_DEFAULTS,
+		configFile,
+		hasPrachtPlugin: /\bpracht\s*\(/.test(rawConfig),
+		mode: "manifest",
+		rawConfig,
+		root
+	};
+	for (const key of Object.keys(PROJECT_DEFAULTS)) {
+		const value = readQuotedConfigValue(rawConfig, key);
+		if (typeof value === "string") config[key] = normalizeConfigPath(value);
+	}
+	config.mode = config.pagesDir ? "pages" : "manifest";
+	return config;
+}
+function resolveProjectPath(root, configPath) {
+	return resolve(root, `.${configPath}`);
+}
+function resolveScopedFile(root, configDir, fileName) {
+	return resolve(resolveProjectPath(root, configDir), fileName);
+}
+function resolveRouteModulePath(project, routePath, extension) {
+	const segments = segmentsFromRoutePath(routePath);
+	const relativePath = segments.length === 0 ? `index${extension}` : `${segments.join("/")}${extension}`;
+	return {
+		absolutePath: resolve(resolveProjectPath(project.root, project.routesDir), relativePath),
+		relativePath
+	};
+}
+function resolvePagesRouteModulePath(project, routePath, extension) {
+	const segments = segmentsFromRoutePath(routePath);
+	const relativePath = segments.length === 0 ? `index${extension}` : `${segments.join("/")}${extension}`;
+	return {
+		absolutePath: resolve(resolveProjectPath(project.root, project.pagesDir), relativePath),
+		relativePath
+	};
+}
+function resolveApiModulePath(project, endpointPath) {
+	const segments = segmentsFromApiPath(endpointPath);
+	const relativePath = segments.length === 0 ? "index.ts" : `${segments.join("/")}.ts`;
+	return {
+		absolutePath: resolve(resolveProjectPath(project.root, project.apiDir), relativePath),
+		relativePath
+	};
+}
+function displayPath(root, filePath) {
+	return relative(root, filePath) || ".";
+}
+function writeGeneratedFile(filePath, source) {
+	if (existsSync(filePath)) throw new Error(`Refusing to overwrite existing file ${filePath}.`);
+	mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(filePath, ensureTrailingNewline(source), "utf-8");
+}
+function assertFileExists(filePath, message) {
+	if (!existsSync(filePath)) throw new Error(message);
+}
+function listFilesRecursively(dir) {
+	const files = [];
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		const fullPath = resolve(dir, entry.name);
+		if (entry.isDirectory()) files.push(...listFilesRecursively(fullPath));
+		else files.push(fullPath);
+	}
+	return files;
+}
+function hasPagesAppShell(filePath) {
+	return /^_app\.(ts|tsx|js|jsx)$/.test(basename(filePath));
+}
+function findConfigFile(root) {
+	for (const name of [
+		"vite.config.ts",
+		"vite.config.mts",
+		"vite.config.js",
+		"vite.config.mjs",
+		"vite.config.cjs",
+		"vite.config.cts"
+	]) {
+		const file = resolve(root, name);
+		if (existsSync(file)) return file;
+	}
+	return null;
+}
+function readQuotedConfigValue(source, key) {
+	if (!source) return null;
+	const pattern = new RegExp(`${key}\\s*:\\s*(["'\\\`])([^"'\\\`]+)\\1`);
+	const match = source.match(pattern);
+	return match ? match[2] : null;
+}
+function normalizeConfigPath(value) {
+	if (!value) return value;
+	return value.startsWith("/") ? value : `/${value}`;
+}
+function segmentsFromRoutePath(routePath) {
+	return routePath.split("/").filter(Boolean).map((segment) => {
+		if (segment.startsWith(":")) return `[${segment.slice(1)}]`;
+		if (segment === "*") return "[...slug]";
+		return segment;
+	});
+}
+function segmentsFromApiPath(endpointPath) {
+	return endpointPath.split("/").filter(Boolean).map((segment) => {
+		if (segment.startsWith(":")) return `[${segment.slice(1)}]`;
+		if (segment === "*") return "[...slug]";
+		return segment;
+	});
+}
+//#endregion
+export { requireEnum as _, readProjectConfig as a, resolveProjectPath as c, writeGeneratedFile as d, ensureTrailingNewline as f, quote as g, parseCommaList as h, listFilesRecursively as i, resolveRouteModulePath as l, parseApiMethods as m, displayPath as n, resolveApiModulePath as o, handleCliError as p, hasPagesAppShell as r, resolvePagesRouteModulePath as s, assertFileExists as t, resolveScopedFile as u, requirePositiveInteger as v };

package/dist/verification-Dfl3X4Zo.mjs

@@ -0,0 +1,372 @@
+import { n as extractRegistryEntries, r as extractRelativeModulePaths } from "./manifest-DGq1n5LT.mjs";
+import { a as readProjectConfig, c as resolveProjectPath, i as listFilesRecursively, n as displayPath, r as hasPagesAppShell } from "./project-DydjqBoS.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, relative, resolve } from "node:path";
+import { execFileSync } from "node:child_process";
+//#region src/verification.ts
+const CONFIG_FILE_NAMES = new Set([
+	"vite.config.ts",
+	"vite.config.mts",
+	"vite.config.js",
+	"vite.config.mjs",
+	"vite.config.cjs",
+	"vite.config.cts"
+]);
+const MODULE_SOURCE_RE = /\.(ts|tsx|js|jsx)$/;
+const PAGE_SOURCE_RE = /\.(ts|tsx|js|jsx|md|mdx)$/;
+function runDoctor(root) {
+	const report = runVerification(root);
+	return {
+		checks: report.checks,
+		configFile: report.configFile,
+		mode: report.mode,
+		ok: report.ok
+	};
+}
+function runVerification(root, options = {}) {
+	const project = readProjectConfig(root);
+	const checks = [];
+	const packageJsonPath = resolve(project.root, "package.json");
+	const configDisplayPath = project.configFile ? displayPath(root, project.configFile) : "vite.config.*";
+	const requestedScope = options.changed ? "changed" : "full";
+	collectConfigChecks(project, checks, configDisplayPath);
+	let changedInfo = {
+		files: [],
+		warning: null
+	};
+	if (options.changed) {
+		changedInfo = collectChangedFiles(project.root);
+		if (changedInfo.warning) checks.push(createCheck("warning", changedInfo.warning));
+	}
+	const frameworkFiles = options.changed ? filterFrameworkFiles(project, changedInfo.files, packageJsonPath) : [];
+	const scope = options.changed && !changedInfo.warning && !requiresFullVerification(project, frameworkFiles) ? "changed" : "full";
+	if (project.mode === "pages") collectPagesVerification(project, checks, {
+		changedFiles: frameworkFiles,
+		scope
+	});
+	else collectManifestVerification(project, checks, {
+		changedFiles: frameworkFiles,
+		scope
+	});
+	collectApiVerification(project, checks, {
+		changedFiles: frameworkFiles,
+		scope
+	});
+	collectPackageChecks(project, checks, packageJsonPath);
+	if (options.changed && frameworkFiles.length === 0 && !changedInfo.warning) checks.push(createCheck("ok", "No changed framework files were detected in the current project scope."));
+	return {
+		checks,
+		configFile: project.configFile ? displayPath(root, project.configFile) : null,
+		mode: project.mode,
+		ok: !checks.some((check) => check.status === "error"),
+		requestedScope,
+		scope,
+		changedFiles: changedInfo.files.map((file) => displayPath(project.root, file)),
+		frameworkFiles: frameworkFiles.map((file) => displayPath(project.root, file))
+	};
+}
+function collectConfigChecks(project, checks, configDisplayPath) {
+	if (!project.configFile) checks.push(createCheck("error", "Missing vite config."));
+	else checks.push(createCheck("ok", `Found ${configDisplayPath}.`));
+	if (!project.hasPrachtPlugin) checks.push(createCheck("error", "vite.config does not appear to register the pracht plugin."));
+	else checks.push(createCheck("ok", "Vite config registers the pracht plugin."));
+}
+function collectManifestVerification(project, checks, { changedFiles, scope }) {
+	const manifestPath = resolveProjectPath(project.root, project.appFile);
+	if (!existsSync(manifestPath)) {
+		checks.push(createCheck("error", `App manifest is missing at ${project.appFile}.`));
+		return;
+	}
+	const source = readFileSync(manifestPath, "utf-8");
+	const relativeModules = [...extractRelativeModulePaths(source)];
+	const routeCount = (source.match(/\broute\s*\(/g) ?? []).length;
+	if (scope === "full") {
+		checks.push(createCheck("ok", `Found app manifest at ${project.appFile}.`));
+		if (routeCount === 0) checks.push(createCheck("warning", "No routes were found in the app manifest."));
+		else checks.push(createCheck("ok", `App manifest defines ${routeCount} route${routeCount === 1 ? "" : "s"}.`));
+		const shellEntries = extractRegistryEntries(source, "shells");
+		const middlewareEntries = extractRegistryEntries(source, "middleware");
+		if (shellEntries.length > 0) checks.push(createCheck("ok", `Registered ${shellEntries.length} shell${shellEntries.length === 1 ? "" : "s"}.`));
+		if (middlewareEntries.length > 0) checks.push(createCheck("ok", `Registered ${middlewareEntries.length} middleware module${middlewareEntries.length === 1 ? "" : "s"}.`));
+		const missingModules = relativeModules.map((modulePath) => ({
+			display: modulePath,
+			exists: existsSync(resolve(dirname(manifestPath), modulePath))
+		})).filter((entry) => !entry.exists).map((entry) => entry.display);
+		if (missingModules.length > 0) checks.push(createCheck("error", `Manifest references missing files: ${missingModules.map((item) => JSON.stringify(item)).join(", ")}.`));
+		else checks.push(createCheck("ok", `All ${relativeModules.length} manifest module path${relativeModules.length === 1 ? "" : "s"} resolve.`));
+	} else collectChangedManifestModuleChecks(project, checks, manifestPath, relativeModules, changedFiles);
+}
+function collectChangedManifestModuleChecks(project, checks, manifestPath, relativeModules, changedFiles) {
+	const manifestDir = dirname(manifestPath);
+	const referencedModules = new Set(relativeModules.map(normalizePath));
+	const moduleDirectories = [
+		{
+			dir: resolveProjectPath(project.root, project.routesDir),
+			label: "route module"
+		},
+		{
+			dir: resolveProjectPath(project.root, project.shellsDir),
+			label: "shell module"
+		},
+		{
+			dir: resolveProjectPath(project.root, project.middlewareDir),
+			label: "middleware module"
+		},
+		{
+			dir: resolveProjectPath(project.root, project.serverDir),
+			label: "server module"
+		}
+	];
+	for (const file of changedFiles) {
+		const directory = moduleDirectories.find((entry) => isWithinDirectory(file, entry.dir));
+		if (!directory) continue;
+		if (!MODULE_SOURCE_RE.test(file)) continue;
+		const display = displayPath(project.root, file);
+		const modulePath = normalizePath(toModuleSpecifier(manifestDir, file));
+		const exists = existsSync(file);
+		if (referencedModules.has(modulePath)) {
+			if (exists) checks.push(createCheck("ok", `Changed ${directory.label} ${JSON.stringify(display)} is referenced by the app manifest.`));
+			else checks.push(createCheck("error", `Changed ${directory.label} ${JSON.stringify(display)} was removed but is still referenced by the app manifest.`));
+			continue;
+		}
+		if (exists) checks.push(createCheck("warning", `Changed ${directory.label} ${JSON.stringify(display)} is not referenced by the app manifest.`));
+	}
+}
+function collectPagesVerification(project, checks, { changedFiles, scope }) {
+	const pagesDir = resolveProjectPath(project.root, project.pagesDir);
+	if (!existsSync(pagesDir)) {
+		checks.push(createCheck("error", `Pages directory is missing at ${project.pagesDir}.`));
+		return;
+	}
+	const pages = scanPagesDirectory(pagesDir);
+	const routes = pages.filter((page) => page.kind === "route");
+	const duplicates = collectDuplicateRoutePaths(routes).map((entry) => ({
+		...entry,
+		files: entry.files.map((file) => displayPath(project.root, file))
+	}));
+	if (scope === "full") {
+		checks.push(createCheck("ok", `Found pages directory at ${project.pagesDir}.`));
+		if (routes.length === 0) checks.push(createCheck("warning", "Pages router app does not contain any route files yet."));
+		else checks.push(createCheck("ok", `Found ${routes.length} page route${routes.length === 1 ? "" : "s"}.`));
+		if (!pages.some((page) => page.kind === "shell")) checks.push(createCheck("warning", "No `_app` shell was found in the pages directory."));
+		else checks.push(createCheck("ok", "Found a pages-router `_app` shell."));
+	} else collectChangedPagesChecks(project, checks, pagesDir, changedFiles);
+	if (duplicates.length > 0) checks.push(createCheck("error", `Pages router resolves duplicate paths: ${duplicates.map((entry) => `${JSON.stringify(entry.path)} from ${entry.files.map((file) => JSON.stringify(file)).join(", ")}`).join("; ")}.`));
+	else if (scope === "full" && routes.length > 0) checks.push(createCheck("ok", `Pages router resolved ${routes.length} route${routes.length === 1 ? "" : "s"} without path collisions.`));
+}
+function collectChangedPagesChecks(project, checks, pagesDir, changedFiles) {
+	for (const file of changedFiles) {
+		if (!isWithinDirectory(file, pagesDir)) continue;
+		if (!PAGE_SOURCE_RE.test(file)) continue;
+		const display = displayPath(project.root, file);
+		if (!existsSync(file)) {
+			checks.push(createCheck("ok", `Removed page file ${JSON.stringify(display)} is no longer auto-discovered.`));
+			continue;
+		}
+		const page = describePagesFile(pagesDir, file);
+		if (page.kind === "shell") {
+			checks.push(createCheck("ok", `Changed pages shell ${JSON.stringify(display)} will wrap auto-discovered routes.`));
+			continue;
+		}
+		if (page.kind === "ignored") {
+			checks.push(createCheck("warning", `Changed pages file ${JSON.stringify(display)} is ignored by the pages router.`));
+			continue;
+		}
+		checks.push(createCheck("ok", `Changed page route ${JSON.stringify(display)} resolves to ${JSON.stringify(page.routePath)}.`));
+	}
+}
+function collectApiVerification(project, checks, { changedFiles, scope }) {
+	const apiDir = resolveProjectPath(project.root, project.apiDir);
+	const changedApiFiles = changedFiles.filter((file) => isWithinDirectory(file, apiDir));
+	if (scope === "changed" && changedApiFiles.length === 0) return;
+	if (!existsSync(apiDir)) {
+		if (scope === "full") checks.push(createCheck("ok", `No API directory was found at ${project.apiDir}; skipping API discovery.`));
+		return;
+	}
+	const apiFiles = listFilesRecursively(apiDir).filter((file) => MODULE_SOURCE_RE.test(file));
+	const routeMap = /* @__PURE__ */ new Map();
+	for (const file of apiFiles) {
+		const routePath = resolveApiRoutePath(apiDir, file);
+		const display = displayPath(project.root, file);
+		const entries = routeMap.get(routePath) ?? [];
+		entries.push(display);
+		routeMap.set(routePath, entries);
+	}
+	const duplicates = [...routeMap.entries()].filter(([, files]) => files.length > 1).map(([path, files]) => ({
+		files,
+		path
+	}));
+	if (duplicates.length > 0) checks.push(createCheck("error", `API route discovery resolves duplicate paths: ${duplicates.map((entry) => `${JSON.stringify(entry.path)} from ${entry.files.map((file) => JSON.stringify(file)).join(", ")}`).join("; ")}.`));
+	else if (scope === "full") checks.push(createCheck("ok", `API route discovery resolved ${apiFiles.length} route${apiFiles.length === 1 ? "" : "s"}.`));
+	for (const file of changedApiFiles) {
+		if (!MODULE_SOURCE_RE.test(file)) continue;
+		const display = displayPath(project.root, file);
+		if (!existsSync(file)) {
+			checks.push(createCheck("ok", `Removed API route ${JSON.stringify(display)} is no longer auto-discovered.`));
+			continue;
+		}
+		checks.push(createCheck("ok", `Changed API route ${JSON.stringify(display)} resolves to ${JSON.stringify(resolveApiRoutePath(apiDir, file))}.`));
+	}
+}
+function collectPackageChecks(project, checks, packageJsonPath) {
+	if (!existsSync(packageJsonPath)) {
+		checks.push(createCheck("warning", "No package.json found in the current app root."));
+		return;
+	}
+	const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+	const deps = {
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	};
+	if (!("@pracht/cli" in deps)) checks.push(createCheck("warning", "`@pracht/cli` is not listed in package.json dependencies."));
+	const adapterPackages = Object.keys(deps).filter((name) => name.startsWith("@pracht/adapter-"));
+	if (adapterPackages.length === 0) checks.push(createCheck("warning", "No built-in pracht adapter dependency was found in package.json."));
+	else checks.push(createCheck("ok", `Found adapter dependency ${adapterPackages.map((name) => JSON.stringify(name)).join(", ")}.`));
+}
+function collectChangedFiles(root) {
+	try {
+		const repoRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+			cwd: root,
+			encoding: "utf-8"
+		}).trim();
+		const prefix = execFileSync("git", ["rev-parse", "--show-prefix"], {
+			cwd: root,
+			encoding: "utf-8"
+		}).trim();
+		const output = execFileSync("git", [
+			"status",
+			"--porcelain",
+			"--untracked-files=all"
+		], {
+			cwd: repoRoot,
+			encoding: "utf-8"
+		});
+		const files = /* @__PURE__ */ new Set();
+		for (const line of output.split(/\r?\n/).filter(Boolean)) {
+			const record = line.slice(3);
+			if (!record) continue;
+			if (record.includes(" -> ")) {
+				const [from, to] = record.split(" -> ");
+				addChangedFile(files, repoRoot, prefix, from);
+				addChangedFile(files, repoRoot, prefix, to);
+			} else addChangedFile(files, repoRoot, prefix, record);
+		}
+		return {
+			files: [...files],
+			warning: null
+		};
+	} catch {
+		return {
+			files: [],
+			warning: "Unable to determine changed files from git; ran full verification instead."
+		};
+	}
+}
+function addChangedFile(files, repoRoot, prefix, repoRelativePath) {
+	if (prefix && !repoRelativePath.startsWith(prefix)) return;
+	const projectRelativePath = prefix ? repoRelativePath.slice(prefix.length) : repoRelativePath;
+	if (!projectRelativePath) return;
+	files.add(resolve(repoRoot, projectRelativePath));
+}
+function filterFrameworkFiles(project, files, packageJsonPath) {
+	const appFile = resolveProjectPath(project.root, project.appFile);
+	const routesDir = resolveProjectPath(project.root, project.routesDir);
+	const shellsDir = resolveProjectPath(project.root, project.shellsDir);
+	const middlewareDir = resolveProjectPath(project.root, project.middlewareDir);
+	const serverDir = resolveProjectPath(project.root, project.serverDir);
+	const apiDir = resolveProjectPath(project.root, project.apiDir);
+	const pagesDir = project.pagesDir ? resolveProjectPath(project.root, project.pagesDir) : null;
+	return files.filter((file) => {
+		if (CONFIG_FILE_NAMES.has(basename(file))) return true;
+		if (normalizePath(file) === normalizePath(packageJsonPath)) return true;
+		if (project.mode === "manifest" && normalizePath(file) === normalizePath(appFile)) return true;
+		if (isWithinDirectory(file, routesDir) && MODULE_SOURCE_RE.test(file)) return true;
+		if (isWithinDirectory(file, shellsDir) && MODULE_SOURCE_RE.test(file)) return true;
+		if (isWithinDirectory(file, middlewareDir) && MODULE_SOURCE_RE.test(file)) return true;
+		if (isWithinDirectory(file, serverDir) && MODULE_SOURCE_RE.test(file)) return true;
+		if (isWithinDirectory(file, apiDir) && MODULE_SOURCE_RE.test(file)) return true;
+		if (pagesDir && isWithinDirectory(file, pagesDir) && PAGE_SOURCE_RE.test(file)) return true;
+		return false;
+	});
+}
+function requiresFullVerification(project, changedFiles) {
+	const packageJsonPath = resolve(project.root, "package.json");
+	const appFile = resolveProjectPath(project.root, project.appFile);
+	return changedFiles.some((file) => {
+		const normalized = normalizePath(file);
+		if (CONFIG_FILE_NAMES.has(basename(file))) return true;
+		if (normalized === normalizePath(packageJsonPath)) return true;
+		if (project.mode === "manifest" && normalized === normalizePath(appFile)) return true;
+		return false;
+	});
+}
+function scanPagesDirectory(pagesDir) {
+	return listFilesRecursively(pagesDir).filter((file) => PAGE_SOURCE_RE.test(file)).map((file) => describePagesFile(pagesDir, file));
+}
+function describePagesFile(pagesDir, file) {
+	const routePath = relative(pagesDir, file).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mdx?)$/, "");
+	const name = basename(routePath);
+	if (hasPagesAppShell(file)) return {
+		file,
+		kind: "shell"
+	};
+	if (name.startsWith("_")) return {
+		file,
+		kind: "ignored"
+	};
+	if (routePath === "index") return {
+		file,
+		kind: "route",
+		routePath: "/"
+	};
+	return {
+		file,
+		kind: "route",
+		routePath: normalizeRoutePath(`/${routePath.replace(/\/index$/, "").replace(/\[\.\.\.([^\]]+)\]/g, "*").replace(/\[([^\].]+)\]/g, ":$1")}`)
+	};
+}
+function collectDuplicateRoutePaths(routes) {
+	const routeMap = /* @__PURE__ */ new Map();
+	for (const route of routes) {
+		const files = routeMap.get(route.routePath) ?? [];
+		files.push(route.file);
+		routeMap.set(route.routePath, files);
+	}
+	return [...routeMap.entries()].filter(([, files]) => files.length > 1).map(([path, files]) => ({
+		files,
+		path
+	}));
+}
+function resolveApiRoutePath(apiDir, file) {
+	let relativePath = relative(apiDir, file).replace(/\\/g, "/");
+	relativePath = relativePath.replace(/\.(ts|tsx|js|jsx)$/, "");
+	if (relativePath === "index") relativePath = "";
+	else relativePath = relativePath.replace(/\/index$/, "");
+	relativePath = relativePath.replace(/\[([^\]]+)\]/g, ":$1");
+	return normalizeRoutePath(relativePath ? `/api/${relativePath}` : "/api");
+}
+function toModuleSpecifier(fromDir, filePath) {
+	const relativePath = relative(fromDir, filePath).replace(/\\/g, "/");
+	if (relativePath.startsWith(".")) return relativePath;
+	return `./${relativePath}`;
+}
+function normalizeRoutePath(path) {
+	if (!path || path === "/") return "/";
+	const collapsed = (path.startsWith("/") ? path : `/${path}`).replace(/\/{2,}/g, "/");
+	return collapsed.length > 1 && collapsed.endsWith("/") ? collapsed.slice(0, -1) : collapsed;
+}
+function isWithinDirectory(filePath, directoryPath) {
+	const relativePath = relative(directoryPath, filePath);
+	return relativePath === "" || !relativePath.startsWith("..") && !relativePath.startsWith("../");
+}
+function normalizePath(value) {
+	return value.replace(/\\/g, "/");
+}
+function createCheck(status, message) {
+	return {
+		message,
+		status
+	};
+}
+//#endregion
+export { runVerification as n, runDoctor as t };

package/dist/verify-CObGxWtW.mjs

@@ -0,0 +1,31 @@
+import { n as runVerification } from "./verification-Dfl3X4Zo.mjs";
+import { defineCommand } from "citty";
+//#region src/commands/verify.ts
+var verify_default = defineCommand({
+	meta: {
+		name: "verify",
+		description: "Fast framework-aware verification"
+	},
+	args: {
+		changed: {
+			type: "boolean",
+			description: "Only check changed files"
+		},
+		json: {
+			type: "boolean",
+			description: "Output as JSON"
+		}
+	},
+	async run({ args }) {
+		const report = runVerification(process.cwd(), { changed: Boolean(args.changed) });
+		if (args.json) console.log(JSON.stringify(report, null, 2));
+		else {
+			console.log(`Pracht verify (${report.mode} mode, ${report.scope} scope)`);
+			for (const check of report.checks) console.log(`${check.status.toUpperCase().padEnd(7)} ${check.message}`);
+			console.log(report.ok ? "\nNo blocking issues found." : "\nBlocking issues found.");
+		}
+		if (!report.ok) process.exitCode = 1;
+	}
+});
+//#endregion
+export { verify_default as default };

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@pracht/cli",
-  "version": "1.1.4",
+  "version": "1.2.0",
+  "license": "MIT",
   "homepage": "https://github.com/JoviDeCroock/pracht/tree/main/packages/cli",
   "bugs": {
     "url": "https://github.com/JoviDeCroock/pracht/issues"
@@ -18,6 +19,10 @@
     "provenance": true
   },
   "dependencies": {
-    "@pracht/core": "0.2.4"
+    "citty": "^0.1.6",
+    "@pracht/core": "0.2.6"
+  },
+  "scripts": {
+    "build": "tsdown"
   }
 }

package/{lib/build-metadata.js → src/build-metadata.ts}

@@ -3,7 +3,20 @@ import { resolve } from "node:path";
 
 const MANIFEST_PATHS = ["dist/client/.vite/manifest.json", "dist/.vite/manifest.json"];
 
-export function readClientBuildAssets(root = process.cwd()) {
+interface ViteManifestEntry {
+  css?: string[];
+  file: string;
+  imports?: string[];
+  src?: string;
+}
+
+export interface ClientBuildAssets {
+  clientEntryUrl: string | null;
+  cssManifest: Record<string, string[]>;
+  jsManifest: Record<string, string[]>;
+}
+
+export function readClientBuildAssets(root: string = process.cwd()): ClientBuildAssets {
   const manifestPath = MANIFEST_PATHS.map((candidate) => resolve(root, candidate)).find((path) =>
     existsSync(path),
   );
@@ -17,15 +30,15 @@ export function readClientBuildAssets(root = process.cwd()) {
   }
 
   const rawManifest = readFileSync(manifestPath, "utf-8");
-  const manifest = JSON.parse(rawManifest);
+  const manifest: Record<string, ViteManifestEntry> = JSON.parse(rawManifest);
   const clientEntry = manifest["virtual:pracht/client"];
 
-  function collectTransitiveDeps(key) {
-    const css = new Set();
-    const js = new Set();
-    const visited = new Set();
+  function collectTransitiveDeps(key: string): { css: string[]; js: string[] } {
+    const css = new Set<string>();
+    const js = new Set<string>();
+    const visited = new Set<string>();
 
-    function collect(currentKey) {
+    function collect(currentKey: string): void {
       if (visited.has(currentKey)) return;
       visited.add(currentKey);
 
@@ -50,8 +63,8 @@ export function readClientBuildAssets(root = process.cwd()) {
     };
   }
 
-  const cssManifest = {};
-  const jsManifest = {};
+  const cssManifest: Record<string, string[]> = {};
+  const jsManifest: Record<string, string[]> = {};
 
   for (const [key, entry] of Object.entries(manifest)) {
     if (!entry.src) continue;