bejamas 0.0.0-canary.0cf9645

package/dist/index.js

@@ -0,0 +1,783 @@
+#!/usr/bin/env node
+import { highlighter, logger, spinner } from "./spinner-9iMQF079.js";
+import { Command } from "commander";
+import { createRequire } from "module";
+import path from "path";
+import fsExtra from "fs-extra";
+import os from "os";
+import dotenv from "dotenv";
+import { detect } from "@antfu/ni";
+import { z } from "zod";
+import { execa } from "execa";
+import prompts from "prompts";
+import { configSchema, rawConfigSchema } from "shadcn/schema";
+import fg from "fast-glob";
+import { createMatchPath, loadConfig } from "tsconfig-paths";
+import { cosmiconfig } from "cosmiconfig";
+import { dirname as dirname$1, isAbsolute, relative as relative$1, resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+//#region src/utils/errors.ts
+const MISSING_DIR_OR_EMPTY_PROJECT = "1";
+
+//#endregion
+//#region src/preflights/preflight-init.ts
+async function preFlightInit(options) {
+	const errors = {};
+	if (!fsExtra.existsSync(options.cwd) || !fsExtra.existsSync(path.resolve(options.cwd, "package.json"))) {
+		errors[MISSING_DIR_OR_EMPTY_PROJECT] = true;
+		return {
+			errors,
+			projectInfo: null
+		};
+	}
+	return {
+		errors,
+		projectInfo: null
+	};
+}
+
+//#endregion
+//#region src/registry/constants.ts
+const REGISTRY_URL = process.env.REGISTRY_URL ?? "http://localhost:4321/r";
+const BASE_COLORS = [
+	{
+		name: "neutral",
+		label: "Neutral"
+	},
+	{
+		name: "gray",
+		label: "Gray"
+	},
+	{
+		name: "zinc",
+		label: "Zinc"
+	},
+	{
+		name: "stone",
+		label: "Stone"
+	},
+	{
+		name: "slate",
+		label: "Slate"
+	}
+];
+const BUILTIN_REGISTRIES = { "@bejamas": `${REGISTRY_URL}/{name}.json` };
+
+//#endregion
+//#region src/registry/context.ts
+let context = { headers: {} };
+function clearRegistryContext() {
+	context.headers = {};
+}
+
+//#endregion
+//#region src/utils/get-package-manager.ts
+async function getPackageManager(targetDir, { withFallback } = { withFallback: false }) {
+	const packageManager = await detect({
+		programmatic: true,
+		cwd: targetDir
+	});
+	if (packageManager === "yarn@berry") return "yarn";
+	if (packageManager === "pnpm@6") return "pnpm";
+	if (packageManager === "bun") return "bun";
+	if (packageManager === "deno") return "deno";
+	if (!withFallback) return packageManager ?? "npm";
+	const userAgent = process.env.npm_config_user_agent || "";
+	if (userAgent.startsWith("yarn")) return "yarn";
+	if (userAgent.startsWith("pnpm")) return "pnpm";
+	if (userAgent.startsWith("bun")) return "bun";
+	return "npm";
+}
+async function getPackageRunner(cwd) {
+	const packageManager = await getPackageManager(cwd);
+	if (packageManager === "pnpm") return "pnpm dlx";
+	if (packageManager === "bun") return "bunx";
+	return "npx";
+}
+
+//#endregion
+//#region src/registry/errors.ts
+const RegistryErrorCode = {
+	NETWORK_ERROR: "NETWORK_ERROR",
+	NOT_FOUND: "NOT_FOUND",
+	UNAUTHORIZED: "UNAUTHORIZED",
+	FORBIDDEN: "FORBIDDEN",
+	FETCH_ERROR: "FETCH_ERROR",
+	NOT_CONFIGURED: "NOT_CONFIGURED",
+	INVALID_CONFIG: "INVALID_CONFIG",
+	MISSING_ENV_VARS: "MISSING_ENV_VARS",
+	LOCAL_FILE_ERROR: "LOCAL_FILE_ERROR",
+	PARSE_ERROR: "PARSE_ERROR",
+	VALIDATION_ERROR: "VALIDATION_ERROR",
+	UNKNOWN_ERROR: "UNKNOWN_ERROR"
+};
+var RegistryError = class extends Error {
+	constructor(message, options = {}) {
+		super(message);
+		this.name = "RegistryError";
+		this.code = options.code || RegistryErrorCode.UNKNOWN_ERROR;
+		this.statusCode = options.statusCode;
+		this.cause = options.cause;
+		this.context = options.context;
+		this.suggestion = options.suggestion;
+		this.timestamp = /* @__PURE__ */ new Date();
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			code: this.code,
+			statusCode: this.statusCode,
+			context: this.context,
+			suggestion: this.suggestion,
+			timestamp: this.timestamp,
+			stack: this.stack
+		};
+	}
+};
+
+//#endregion
+//#region src/utils/handle-error.ts
+function handleError(error) {
+	logger.break();
+	logger.error(`Something went wrong. Please check the error below for more details.`);
+	logger.error(`If the problem persists, please open an issue on GitHub: https://github.com/bejamas/ui/issues`);
+	logger.error("");
+	if (typeof error === "string") {
+		logger.error(error);
+		logger.break();
+		process.exit(1);
+	}
+	if (error instanceof RegistryError) {
+		if (error.message) {
+			logger.error(error.cause ? "Error:" : "Message:");
+			logger.error(error.message);
+		}
+		if (error.cause) {
+			logger.error("\nMessage:");
+			logger.error(error.cause);
+		}
+		if (error.suggestion) {
+			logger.error("\nSuggestion:");
+			logger.error(error.suggestion);
+		}
+		logger.break();
+		process.exit(1);
+	}
+	if (error instanceof z.ZodError) {
+		logger.error("Validation failed:");
+		for (const [key, value] of Object.entries(error.flatten().fieldErrors)) logger.error(`- ${highlighter.info(key)}: ${value}`);
+		logger.break();
+		process.exit(1);
+	}
+	if (error instanceof Error) {
+		logger.error(error.message);
+		logger.break();
+		process.exit(1);
+	}
+	logger.break();
+	process.exit(1);
+}
+
+//#endregion
+//#region src/utils/create-project.ts
+const TEMPLATES = {
+	astro: "astro",
+	"astro-monorepo": "astro-monorepo",
+	"astro-with-component-docs-monorepo": "astro-with-component-docs-monorepo"
+};
+const MONOREPO_TEMPLATE_URL = "https://codeload.github.com/bejamas/ui/tar.gz/main";
+async function createProject(options) {
+	options = {
+		srcDir: false,
+		...options
+	};
+	let template = options.template && TEMPLATES[options.template] ? options.template : "astro";
+	let projectName = "my-app";
+	const isRemoteComponent = options.components?.length === 1 && !!options.components[0].match(/\/chat\/b\//);
+	if (!options.force) {
+		const { type, name } = await prompts([{
+			type: options.template || isRemoteComponent ? null : "select",
+			name: "type",
+			message: `The path ${highlighter.info(options.cwd)} does not contain a package.json file.\n  Would you like to start a new project?`,
+			choices: [
+				{
+					title: "Astro",
+					value: "astro"
+				},
+				{
+					title: "Astro (Monorepo)",
+					value: "astro-monorepo"
+				},
+				{
+					title: "Astro with Component Docs (Monorepo)",
+					value: "astro-with-component-docs-monorepo"
+				}
+			],
+			initial: 0
+		}, {
+			type: "text",
+			name: "name",
+			message: "What is your project named?",
+			initial: (_prev, values) => {
+				return (options.template && TEMPLATES[options.template] && options.template || values.type || template)?.endsWith("monorepo") ? "my-monorepo" : "my-app";
+			},
+			format: (value) => value.trim(),
+			validate: (value) => value.length > 128 ? `Name should be less than 128 characters.` : true
+		}]);
+		template = type ?? template;
+		projectName = name;
+	}
+	const packageManager = await getPackageManager(options.cwd, { withFallback: true });
+	const projectPath = `${options.cwd}/${projectName}`;
+	try {
+		await fsExtra.access(options.cwd, fsExtra.constants.W_OK);
+	} catch (error) {
+		logger.break();
+		logger.error(`The path ${highlighter.info(options.cwd)} is not writable.`);
+		logger.error(`It is likely you do not have write permissions for this folder or the path ${highlighter.info(options.cwd)} does not exist.`);
+		logger.break();
+		process.exit(1);
+	}
+	if (fsExtra.existsSync(path.resolve(options.cwd, projectName, "package.json"))) {
+		logger.break();
+		logger.error(`A project with the name ${highlighter.info(projectName)} already exists.`);
+		logger.error(`Please choose a different name and try again.`);
+		logger.break();
+		process.exit(1);
+	}
+	await createProjectFromTemplate(projectPath, {
+		templateKey: template,
+		packageManager,
+		cwd: options.cwd
+	});
+	return {
+		projectPath,
+		projectName,
+		template
+	};
+}
+async function createProjectFromTemplate(projectPath, options) {
+	const createSpinner = spinner(`Creating a new project from template. This may take a few minutes.`).start();
+	const TEMPLATE_TAR_SUBPATH = {
+		astro: "ui-main/templates/astro",
+		"astro-monorepo": "ui-main/templates/monorepo-astro",
+		"astro-with-component-docs-monorepo": "ui-main/templates/monorepo-astro-with-docs"
+	};
+	try {
+		dotenv.config({ quiet: true });
+		const templatePath = path.join(os.tmpdir(), `bejamas-template-${Date.now()}`);
+		await fsExtra.ensureDir(templatePath);
+		const authToken = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+		const usedAuth = Boolean(authToken);
+		const headers = { "User-Agent": "bejamas-cli" };
+		if (authToken) headers["Authorization"] = `Bearer ${authToken}`;
+		const response = await fetch(MONOREPO_TEMPLATE_URL, { headers });
+		if (!response.ok) {
+			if (response.status === 401 || response.status === 403 || !usedAuth && response.status === 404) throw new Error("Unauthorized to access private template. Set GITHUB_TOKEN or GH_TOKEN (in .env or env) with repo access and try again.");
+			if (response.status === 404) throw new Error("Failed to download template: not found.");
+			throw new Error(`Failed to download template: ${response.status} ${response.statusText}`);
+		}
+		const tarPath = path.resolve(templatePath, "template.tar.gz");
+		await fsExtra.writeFile(tarPath, Buffer.from(await response.arrayBuffer()));
+		const tarSubpath = TEMPLATE_TAR_SUBPATH[options.templateKey];
+		const leafName = tarSubpath.split("/").pop();
+		await execa("tar", [
+			"-xzf",
+			tarPath,
+			"-C",
+			templatePath,
+			"--strip-components=2",
+			tarSubpath
+		]);
+		const extractedPath = path.resolve(templatePath, leafName);
+		await fsExtra.move(extractedPath, projectPath);
+		await fsExtra.remove(templatePath);
+		await execa(options.packageManager, ["install"], { cwd: projectPath });
+		try {
+			const { stdout } = await execa("git", ["rev-parse", "--is-inside-work-tree"], { cwd: projectPath });
+			if (!(stdout.trim() === "true")) {
+				await execa("git", ["init"], { cwd: projectPath });
+				await execa("git", ["add", "-A"], { cwd: projectPath });
+				await execa("git", [
+					"commit",
+					"-m",
+					"Initial commit"
+				], { cwd: projectPath });
+			}
+		} catch (_) {}
+		createSpinner?.succeed("Creating a new project from template.");
+	} catch (error) {
+		createSpinner?.fail("Something went wrong creating a new project from template.");
+		handleError(error);
+	}
+}
+
+//#endregion
+//#region src/utils/get-package-info.ts
+function getPackageInfo(cwd = "", shouldThrow = true) {
+	const packageJsonPath = path.join(cwd, "package.json");
+	return fsExtra.readJSONSync(packageJsonPath, { throws: shouldThrow });
+}
+
+//#endregion
+//#region src/utils/get-project-info.ts
+const PROJECT_SHARED_IGNORE = [
+	"**/node_modules/**",
+	".astro",
+	"public",
+	"dist",
+	"build"
+];
+const TS_CONFIG_SCHEMA = z.object({ compilerOptions: z.object({ paths: z.record(z.string().or(z.array(z.string()))) }) });
+async function getProjectInfo(cwd) {
+	const [configFiles, tailwindConfigFile, tailwindCssFile, tailwindVersion, aliasPrefix, packageJson] = await Promise.all([
+		fg.glob("**/{next,vite,astro,app}.config.*|gatsby-config.*|composer.json|react-router.config.*", {
+			cwd,
+			deep: 3,
+			ignore: PROJECT_SHARED_IGNORE
+		}),
+		getTailwindConfigFile(cwd),
+		getTailwindCssFile(cwd),
+		getTailwindVersion(cwd),
+		getTsConfigAliasPrefix(cwd),
+		getPackageInfo(cwd, false)
+	]);
+	const type = {
+		isAstro: false,
+		tailwindConfigFile,
+		tailwindCssFile,
+		tailwindVersion,
+		aliasPrefix
+	};
+	if (configFiles.find((file) => file.startsWith("astro.config."))?.length) {
+		type.isAstro = true;
+		return type;
+	}
+	return type;
+}
+async function getTailwindVersion(cwd) {
+	const [packageInfo, config] = await Promise.all([getPackageInfo(cwd, false), getConfig(cwd)]);
+	if (config?.tailwind?.config === "") return "v4";
+	if (!packageInfo?.dependencies?.tailwindcss && !packageInfo?.devDependencies?.tailwindcss) return null;
+	if (/^(?:\^|~)?3(?:\.\d+)*(?:-.*)?$/.test(packageInfo?.dependencies?.tailwindcss || packageInfo?.devDependencies?.tailwindcss || "")) return "v3";
+	return "v4";
+}
+async function getTailwindCssFile(cwd) {
+	const [files, tailwindVersion] = await Promise.all([fg.glob(["**/*.css", "**/*.scss"], {
+		cwd,
+		deep: 5,
+		ignore: PROJECT_SHARED_IGNORE
+	}), getTailwindVersion(cwd)]);
+	if (!files.length) return null;
+	for (const file of files) {
+		const contents = await fsExtra.readFile(path.resolve(cwd, file), "utf8");
+		if (contents.includes(`@import "tailwindcss"`) || contents.includes(`@import 'tailwindcss'`) || contents.includes(`@tailwind base`)) return file;
+	}
+	return null;
+}
+async function getTailwindConfigFile(cwd) {
+	const files = await fg.glob("tailwind.config.*", {
+		cwd,
+		deep: 3,
+		ignore: PROJECT_SHARED_IGNORE
+	});
+	if (!files.length) return null;
+	return files[0];
+}
+async function getTsConfigAliasPrefix(cwd) {
+	const tsConfig = await loadConfig(cwd);
+	if (tsConfig?.resultType === "failed" || !Object.entries(tsConfig?.paths).length) return null;
+	for (const [alias, paths] of Object.entries(tsConfig.paths)) if (paths.includes("./*") || paths.includes("./src/*") || paths.includes("./app/*") || paths.includes("./resources/js/*")) return alias.replace(/\/\*$/, "") ?? null;
+	return Object.keys(tsConfig?.paths)?.[0].replace(/\/\*$/, "") ?? null;
+}
+
+//#endregion
+//#region src/utils/resolve-import.ts
+async function resolveImport(importPath, config) {
+	return createMatchPath(config.absoluteBaseUrl, config.paths)(importPath, void 0, () => true, [
+		".ts",
+		".tsx",
+		".jsx",
+		".js",
+		".css"
+	]);
+}
+
+//#endregion
+//#region src/utils/get-config.ts
+const explorer = cosmiconfig("components", { searchPlaces: ["components.json"] });
+async function getConfig(cwd) {
+	const config = await getRawConfig(cwd);
+	if (!config) return null;
+	if (!config.iconLibrary) config.iconLibrary = config.style === "new-york" ? "radix" : "lucide";
+	return await resolveConfigPaths(cwd, config);
+}
+async function resolveConfigPaths(cwd, config) {
+	config.registries = {
+		...BUILTIN_REGISTRIES,
+		...config.registries || {}
+	};
+	const tsConfig = await loadConfig(cwd);
+	if (tsConfig.resultType === "failed") throw new Error(`Failed to load ${config.tsx ? "tsconfig" : "jsconfig"}.json. ${tsConfig.message ?? ""}`.trim());
+	return configSchema.parse({
+		...config,
+		resolvedPaths: {
+			cwd,
+			tailwindConfig: config.tailwind.config ? path.resolve(cwd, config.tailwind.config) : "",
+			tailwindCss: path.resolve(cwd, config.tailwind.css),
+			utils: await resolveImport(config.aliases["utils"], tsConfig),
+			components: await resolveImport(config.aliases["components"], tsConfig),
+			ui: config.aliases["ui"] ? await resolveImport(config.aliases["ui"], tsConfig) : path.resolve(await resolveImport(config.aliases["components"], tsConfig) ?? cwd, "ui"),
+			lib: config.aliases["lib"] ? await resolveImport(config.aliases["lib"], tsConfig) : path.resolve(await resolveImport(config.aliases["utils"], tsConfig) ?? cwd, ".."),
+			hooks: config.aliases["hooks"] ? await resolveImport(config.aliases["hooks"], tsConfig) : path.resolve(await resolveImport(config.aliases["components"], tsConfig) ?? cwd, "..", "hooks")
+		}
+	});
+}
+async function getRawConfig(cwd) {
+	try {
+		const configResult = await explorer.search(cwd);
+		if (!configResult) return null;
+		const config = rawConfigSchema.parse(configResult.config);
+		if (config.registries) {
+			for (const registryName of Object.keys(config.registries)) if (registryName in BUILTIN_REGISTRIES) throw new Error(`"${registryName}" is a built-in registry and cannot be overridden.`);
+		}
+		return config;
+	} catch (error) {
+		const componentPath = `${cwd}/components.json`;
+		if (error instanceof Error && error.message.includes("reserved registry")) throw error;
+		throw new Error(`Invalid configuration found in ${highlighter.info(componentPath)}.`);
+	}
+}
+
+//#endregion
+//#region src/commands/init.ts
+const initOptionsSchema = z.object({
+	cwd: z.string(),
+	components: z.array(z.string()).optional(),
+	yes: z.boolean(),
+	defaults: z.boolean(),
+	force: z.boolean(),
+	silent: z.boolean(),
+	isNewProject: z.boolean(),
+	srcDir: z.boolean().optional(),
+	cssVariables: z.boolean(),
+	template: z.string().optional().refine((val) => {
+		if (val) return TEMPLATES[val];
+		return true;
+	}, { message: "Invalid template. Please use 'next' or 'next-monorepo'." }),
+	baseColor: z.string().optional().refine((val) => {
+		if (val) return BASE_COLORS.find((color) => color.name === val);
+		return true;
+	}, { message: `Invalid base color. Please use '${BASE_COLORS.map((color) => color.name).join("', '")}'` }),
+	baseStyle: z.boolean()
+});
+const init = new Command().name("init").description("initialize your project and install dependencies").argument("[components...]", "names, url or local path to component").option("-t, --template <template>", "the template to use. (next, next-monorepo)").option("-b, --base-color <base-color>", "the base color to use. (neutral, gray, zinc, stone, slate)", void 0).option("-y, --yes", "skip confirmation prompt.", true).option("-d, --defaults,", "use default configuration.", false).option("-f, --force", "force overwrite of existing configuration.", false).option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("-s, --silent", "mute output.", false).option("--src-dir", "use the src directory when creating a new project.", false).option("--no-src-dir", "do not use the src directory when creating a new project.").option("--css-variables", "use css variables for theming.", true).option("--no-css-variables", "do not use css variables for theming.").option("--no-base-style", "do not install the base shadcn style.").action(async (_components, opts) => {
+	try {
+		await runInit(opts);
+	} catch (error) {
+		logger.break();
+		handleError(error);
+	} finally {
+		clearRegistryContext();
+	}
+});
+async function runInit(options) {
+	let newProjectTemplate;
+	if (!options.skipPreflight) {
+		const preflight = await preFlightInit(options);
+		if (preflight.errors[MISSING_DIR_OR_EMPTY_PROJECT]) {
+			const { projectPath, template } = await createProject(options);
+			if (!projectPath) process.exit(1);
+			options.cwd = projectPath;
+			options.isNewProject = true;
+			newProjectTemplate = template;
+		}
+		preflight.projectInfo;
+	} else await getProjectInfo(options.cwd);
+	if (newProjectTemplate) {
+		options.cwd = path.resolve(options.cwd, {
+			"astro-monorepo": "apps/web",
+			"astro-with-component-docs-monorepo": "apps/web",
+			astro: ""
+		}[newProjectTemplate]);
+		logger.log(`${highlighter.success("Success!")} Project initialization completed.\nYou may now add components.`);
+		return await getConfig(options.cwd);
+	}
+	const shadcnBin = process.platform === "win32" ? "shadcn.cmd" : "shadcn";
+	const localShadcnPath = path.resolve(options.cwd, "node_modules", ".bin", shadcnBin);
+	try {
+		const env = { ...process.env };
+		if (process.env.REGISTRY_URL) env.REGISTRY_URL = process.env.REGISTRY_URL;
+		if (await fsExtra.pathExists(localShadcnPath)) await execa(localShadcnPath, [
+			"init",
+			"--base-color",
+			"neutral"
+		], {
+			stdio: "inherit",
+			cwd: options.cwd,
+			env
+		});
+		else await execa("npx", [
+			"-y",
+			"shadcn@latest",
+			"init",
+			"--base-color",
+			"neutral"
+		], {
+			stdio: "inherit",
+			cwd: options.cwd,
+			env
+		});
+	} catch (err) {
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/commands/docs.ts
+const __filename = fileURLToPath(import.meta.url);
+dirname$1(__filename);
+function readTsConfig(projectRoot) {
+	try {
+		const tsconfigPath = resolve(projectRoot, "tsconfig.json");
+		if (!existsSync(tsconfigPath)) return null;
+		const raw = readFileSync(tsconfigPath, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+function resolveAliasPathUsingTsConfig(inputPath, projectRoot) {
+	const cfg = readTsConfig(projectRoot);
+	if (!cfg || !cfg.compilerOptions) return null;
+	const baseUrl = cfg.compilerOptions.baseUrl || ".";
+	const paths = cfg.compilerOptions.paths || {};
+	for (const [key, values] of Object.entries(paths)) {
+		const pattern = key.replace(/\*/g, "(.*)");
+		const re = /* @__PURE__ */ new RegExp(`^${pattern}$`);
+		const match = inputPath.match(re);
+		if (!match) continue;
+		const wildcard = match[1] || "";
+		const first = Array.isArray(values) ? values[0] : values;
+		if (!first) continue;
+		const target = String(first).replace(/\*/g, wildcard);
+		return resolve(projectRoot, baseUrl, target);
+	}
+	return null;
+}
+async function generateDocs({ cwd, outDir, verbose }) {
+	const DEBUG = process.env.BEJAMAS_DEBUG === "1" || process.env.BEJAMAS_DEBUG === "true" || verbose;
+	try {
+		const shellCwd = process.cwd();
+		let projectRoot = shellCwd;
+		let probe = shellCwd;
+		for (let i = 0; i < 6 && probe; i += 1) {
+			const candidate = resolve(probe, "components.json");
+			if (existsSync(candidate)) {
+				projectRoot = probe;
+				try {
+					const raw = readFileSync(candidate, "utf-8");
+					const config = JSON.parse(raw);
+					if (!cwd && !process.env.BEJAMAS_UI_ROOT && config?.aliases?.ui) {
+						const mapped = String(config.aliases.ui);
+						let uiAbs = null;
+						if (mapped.startsWith("./") || mapped.startsWith("../") || isAbsolute(mapped)) uiAbs = resolve(projectRoot, mapped);
+						else uiAbs = resolveAliasPathUsingTsConfig(mapped, projectRoot);
+						if (!uiAbs && mapped.startsWith("@/")) uiAbs = resolve(projectRoot, "src", mapped.slice(2));
+						if (uiAbs) process.env.BEJAMAS_UI_ROOT = uiAbs;
+					}
+					if (!cwd && !process.env.BEJAMAS_UI_ROOT && config?.tailwind?.css) {
+						const cssRaw = String(config.tailwind.css);
+						let cssAbs = null;
+						if (cssRaw.startsWith("./") || cssRaw.startsWith("../") || isAbsolute(cssRaw)) cssAbs = resolve(projectRoot, cssRaw);
+						else cssAbs = resolveAliasPathUsingTsConfig(cssRaw, projectRoot);
+						if (!cssAbs && cssRaw.startsWith("@/")) cssAbs = resolve(projectRoot, "src", cssRaw.slice(2));
+						if (cssAbs) {
+							const uiRootFromCss = resolve(cssAbs, "..", "..", "..");
+							process.env.BEJAMAS_UI_ROOT = uiRootFromCss;
+						}
+					}
+					if (!outDir && config?.aliases?.docs) {
+						const mapped = String(config.aliases.docs);
+						let outResolved = null;
+						if (mapped.startsWith("./") || mapped.startsWith("../") || isAbsolute(mapped)) outResolved = mapped;
+						else {
+							const abs = resolveAliasPathUsingTsConfig(mapped, projectRoot);
+							if (abs) outResolved = relative$1(projectRoot, abs);
+						}
+						if (!outResolved && mapped.startsWith("@/")) outResolved = mapped.replace(/^@\//, "src/");
+						const finalOut = outResolved ?? mapped;
+						if (finalOut && !process.env.BEJAMAS_DOCS_OUT_DIR) {
+							process.env.BEJAMAS_DOCS_OUT_DIR = finalOut;
+							process.env.BEJAMAS_DOCS_CWD = projectRoot;
+						}
+					}
+				} catch {}
+				break;
+			}
+			const parent = resolve(probe, "..");
+			probe = parent === probe ? null : parent;
+		}
+		if (!process.env.BEJAMAS_DOCS_CWD) process.env.BEJAMAS_DOCS_CWD = shellCwd;
+		if (!process.env.BEJAMAS_UI_ROOT) {
+			const defaultGuess = (() => {
+				let current = shellCwd;
+				for (let i = 0; i < 6; i += 1) {
+					const cand = resolve(current, "packages/ui/package.json");
+					if (existsSync(cand)) {
+						const abs = resolve(current, "packages/ui");
+						return relative$1(shellCwd, abs) || abs;
+					}
+					const parent = resolve(current, "..");
+					if (parent === current) break;
+					current = parent;
+				}
+				const nm = resolve(shellCwd, "node_modules/@bejamas/ui/package.json");
+				if (existsSync(nm)) {
+					const abs = resolve(shellCwd, "node_modules/@bejamas/ui");
+					return relative$1(shellCwd, abs) || abs;
+				}
+				return "packages/ui";
+			})();
+			const { uiRoot } = await prompts({
+				type: "text",
+				name: "uiRoot",
+				message: "Path to @bejamas/ui package root:",
+				initial: defaultGuess,
+				validate: (val) => {
+					const p = resolve(shellCwd, val);
+					return existsSync(resolve(p, "package.json")) ? true : `No package.json found in ${p}`;
+				}
+			});
+			if (!uiRoot) {
+				logger.error("@bejamas/ui root is required to generate docs.");
+				process.exit(1);
+			}
+			process.env.BEJAMAS_UI_ROOT = resolve(shellCwd, uiRoot);
+		}
+		if (cwd && cwd.length) process.env.BEJAMAS_UI_ROOT = resolve(cwd);
+		if (outDir && outDir.length) process.env.BEJAMAS_DOCS_OUT_DIR = outDir;
+		if (!process.env.BEJAMAS_DOCS_OUT_DIR) {
+			const { out } = await prompts({
+				type: "text",
+				name: "out",
+				message: "Where should we output docs (relative to project root)?",
+				initial: "src/content/docs/components"
+			});
+			if (!out) {
+				logger.error("An output directory is required to generate docs.");
+				process.exit(1);
+			}
+			process.env.BEJAMAS_DOCS_OUT_DIR = out;
+			process.env.BEJAMAS_DOCS_CWD = process.env.BEJAMAS_DOCS_CWD || shellCwd;
+		}
+		process.env.BEJAMAS_SKIP_AUTO_RUN = "1";
+		logger.info(`Generating docs...`);
+		if (DEBUG) {
+			logger.info(`Generator entry: @/src/docs/generate-mdx/index`);
+			if (process.env.BEJAMAS_UI_ROOT) logger.info(`UI root: ${process.env.BEJAMAS_UI_ROOT}`);
+			if (process.env.BEJAMAS_DOCS_CWD) logger.info(`Docs CWD: ${process.env.BEJAMAS_DOCS_CWD}`);
+			if (process.env.BEJAMAS_DOCS_OUT_DIR) logger.info(`Docs out: ${process.env.BEJAMAS_DOCS_OUT_DIR}`);
+		}
+		const mod = await import("./generate-mdx-Bq9erbjr.js");
+		if (typeof mod.runDocsGenerator === "function") await mod.runDocsGenerator();
+		else throw new Error("Failed to load docs generator. Export 'runDocsGenerator' not found.");
+	} catch (err) {
+		logger.error(err?.message || String(err));
+		process.exit(1);
+	}
+}
+const docs = new Command().name("docs:build").alias("docs").description("generate docs from @bejamas/ui components").option("-c, --cwd <cwd>", "path to UI working directory").option("-o, --out <outDir>", "output directory for generated MDX files").action(async (opts) => {
+	await generateDocs({
+		cwd: opts.cwd,
+		outDir: opts.out,
+		verbose: Boolean(opts.verbose)
+	});
+});
+
+//#endregion
+//#region src/commands/add.ts
+const DEFAULT_REGISTRY_URL = "https://ui-web-nine.vercel.app/r";
+function extractOptionsForShadcn(rawArgv) {
+	const addIndex = rawArgv.findIndex((arg) => arg === "add");
+	if (addIndex === -1) return [];
+	const rest = rawArgv.slice(addIndex + 1);
+	const forwarded = [];
+	for (let i = 0; i < rest.length; i += 1) {
+		const token = rest[i];
+		if (token === "--") {
+			forwarded.push("--", ...rest.slice(i + 1));
+			break;
+		}
+		if (token.startsWith("-")) {
+			if (token === "-v" || token === "--verbose") continue;
+			forwarded.push(token);
+			const next = rest[i + 1];
+			if (next && !next.startsWith("-")) {
+				forwarded.push(next);
+				i += 1;
+			}
+			continue;
+		}
+	}
+	return forwarded;
+}
+async function addComponents(packages, forwardedOptions, isVerbose) {
+	const runner = await getPackageRunner(process.cwd());
+	const env = {
+		...process.env,
+		REGISTRY_URL: process.env.REGISTRY_URL || DEFAULT_REGISTRY_URL
+	};
+	const baseArgs = [
+		"shadcn@latest",
+		"add",
+		...packages,
+		...forwardedOptions
+	];
+	let cmd = "npx";
+	let args = ["-y", ...baseArgs];
+	if (runner === "bunx") {
+		cmd = "bunx";
+		args = baseArgs;
+	} else if (runner === "pnpm dlx") {
+		cmd = "pnpm";
+		args = ["dlx", ...baseArgs];
+	} else if (runner === "npx") {
+		cmd = "npx";
+		args = ["-y", ...baseArgs];
+	}
+	if (isVerbose) logger.info(`[bejamas-ui] ${cmd} ${args.join(" ")}`);
+	try {
+		await execa(cmd, args, {
+			stdio: "inherit",
+			env
+		});
+	} catch (err) {
+		process.exit(1);
+	}
+}
+const add = new Command().name("add").description("Add components via shadcn@latest using registry URLs").argument("[components...]", "Component package names to add").option("-y, --yes", "skip confirmation prompt.", false).option("-o, --overwrite", "overwrite existing files.", false).option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("-a, --all", "add all available components", false).option("-p, --path <path>", "the path to add the component to.").option("-s, --silent", "mute output.", false).option("--src-dir", "use the src directory when creating a new project.", false).option("--no-src-dir", "do not use the src directory when creating a new project.").action(async function action(packages, _opts, cmd) {
+	const root = cmd?.parent;
+	const verbose = Boolean(root?.opts?.().verbose);
+	const rawArgv = process.argv.slice(2);
+	const forwardedOptions = extractOptionsForShadcn(rawArgv);
+	await addComponents(packages || [], forwardedOptions, verbose);
+});
+
+//#endregion
+//#region src/index.ts
+const pkg = createRequire(import.meta.url)("../package.json");
+const program = new Command().name("bejamas").description("bejamas/ui cli").configureHelp({ helpWidth: Math.min(100, process.stdout.columns || 100) }).version(pkg.version, "-v, --version", "output the version number");
+program.addCommand(init);
+program.addCommand(add);
+program.addCommand(docs);
+program.parse(process.argv);
+var src_default = program;
+
+//#endregion
+export { src_default as default };
+//# sourceMappingURL=index.js.map