bejamas 0.0.0-canary.02ea75e

package/dist/index.js

@@ -0,0 +1,716 @@
+#!/usr/bin/env node
+import { BASE_COLORS, getConfig, getProjectInfo, highlighter, logger, spinner } from "./get-config-CJUwQ2Xb.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 fg from "fast-glob";
+import path$1, { dirname as dirname$1, isAbsolute, relative as relative$1, resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs/promises";
+
+//#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/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/commands/init.ts
+const DEFAULT_REGISTRY_URL$1 = "https://ui.bejamas.com/r";
+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,
+			REGISTRY_URL: process.env.REGISTRY_URL || DEFAULT_REGISTRY_URL$1
+		};
+		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-CR4bXlml.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/utils/astro-imports.ts
+function updateImportAliases(moduleSpecifier, config, isRemote = false) {
+	if (!moduleSpecifier.startsWith("@/") && !isRemote) return moduleSpecifier;
+	let specifier = moduleSpecifier;
+	if (isRemote && specifier.startsWith("@/")) specifier = specifier.replace(/^@\//, "@/registry/new-york/");
+	if (!specifier.startsWith("@/registry/")) {
+		const alias = config.aliases.components.split("/")[0];
+		return specifier.replace(/^@\//, `${alias}/`);
+	}
+	if (specifier.match(/^@\/registry\/(.+)\/ui/)) return specifier.replace(/^@\/registry\/(.+)\/ui/, config.aliases.ui ?? `${config.aliases.components}/ui`);
+	if (config.aliases.components && specifier.match(/^@\/registry\/(.+)\/components/)) return specifier.replace(/^@\/registry\/(.+)\/components/, config.aliases.components);
+	if (config.aliases.lib && specifier.match(/^@\/registry\/(.+)\/lib/)) return specifier.replace(/^@\/registry\/(.+)\/lib/, config.aliases.lib);
+	if (config.aliases.hooks && specifier.match(/^@\/registry\/(.+)\/hooks/)) return specifier.replace(/^@\/registry\/(.+)\/hooks/, config.aliases.hooks);
+	return specifier.replace(/^@\/registry\/[^/]+/, config.aliases.components);
+}
+function rewriteAstroImports(content, config) {
+	let updated = content;
+	const utilsAlias = config.aliases?.utils;
+	const utilsImport = `${typeof utilsAlias === "string" && utilsAlias.includes("/") ? utilsAlias.split("/")[0] : "@"}/lib/utils`;
+	updated = updated.replace(/import\s+([\s\S]*?)\s+from\s+["']([^"']+)["']/g, (full, importsPart, specifier) => {
+		const next = updateImportAliases(specifier, config, false);
+		let finalSpec = next;
+		if (typeof importsPart === "string" && importsPart.split(/[{},\s]/).some((part) => part === "cn") && config.aliases.utils && (next === utilsImport || next === "@/lib/utils")) finalSpec = utilsImport === next ? next.replace(utilsImport, config.aliases.utils) : config.aliases.utils;
+		if (finalSpec === specifier) return full;
+		return full.replace(specifier, finalSpec);
+	});
+	updated = updated.replace(/import\s+["']([^"']+)["']/g, (full, specifier) => {
+		const next = updateImportAliases(specifier, config, false);
+		if (next === specifier) return full;
+		return full.replace(specifier, next);
+	});
+	return updated;
+}
+async function fixAstroImports(cwd, isVerbose) {
+	const config = await getConfig(cwd);
+	if (!config) return;
+	const searchRoots = new Set([config.resolvedPaths.components, config.resolvedPaths.ui]);
+	for (const root of Array.from(searchRoots)) {
+		if (!root) continue;
+		const astroFiles = await fg("**/*.astro", {
+			cwd: root,
+			absolute: true,
+			dot: false
+		});
+		for (const filePath of astroFiles) {
+			const original = await fs.readFile(filePath, "utf8");
+			const rewritten = rewriteAstroImports(original, config);
+			if (rewritten === original) continue;
+			await fs.writeFile(filePath, rewritten, "utf8");
+			if (isVerbose) logger.info(`[bejamas-ui] fixed imports in ${path$1.relative(cwd, filePath)}`);
+		}
+	}
+}
+
+//#endregion
+//#region src/commands/add.ts
+const DEFAULT_REGISTRY_URL = "https://ui.bejamas.com/r";
+function extractOptionsForShadcn(rawArgv, cmd) {
+	if (typeof cmd.getOptionValueSource === "function") {
+		const opts = cmd.optsWithGlobals();
+		const forwarded$1 = [];
+		const getSource = (key) => cmd.getOptionValueSource(key);
+		const addBoolean = (key, flag, negateFlag) => {
+			if (getSource(key) !== "cli") return;
+			const value = opts[key];
+			if (typeof value !== "boolean") return;
+			if (value) forwarded$1.push(flag);
+			else if (negateFlag) forwarded$1.push(negateFlag);
+		};
+		const addString = (key, flag) => {
+			if (getSource(key) !== "cli") return;
+			const value = opts[key];
+			if (typeof value === "string") forwarded$1.push(flag, value);
+		};
+		addBoolean("yes", "--yes");
+		addBoolean("overwrite", "--overwrite");
+		addString("cwd", "--cwd");
+		addBoolean("all", "--all");
+		addString("path", "--path");
+		addBoolean("silent", "--silent");
+		addBoolean("srcDir", "--src-dir", "--no-src-dir");
+		const addIndex$1 = rawArgv.findIndex((arg) => arg === "add");
+		if (addIndex$1 !== -1) {
+			const rest$1 = rawArgv.slice(addIndex$1 + 1);
+			const doubleDashIndex = rest$1.indexOf("--");
+			if (doubleDashIndex !== -1) forwarded$1.push(...rest$1.slice(doubleDashIndex));
+		}
+		return forwarded$1;
+	}
+	const addIndex = rawArgv.findIndex((arg) => arg === "add");
+	if (addIndex === -1) return [];
+	const rest = rawArgv.slice(addIndex + 1);
+	const forwarded = [];
+	const optionsWithValues = new Set([
+		"-c",
+		"--cwd",
+		"-p",
+		"--path"
+	]);
+	const filteredFlags = new Set(["-v", "--verbose"]);
+	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("-")) continue;
+		if (filteredFlags.has(token)) continue;
+		forwarded.push(token);
+		if (token.includes("=")) continue;
+		if (optionsWithValues.has(token)) {
+			const next = rest[i + 1];
+			if (next) {
+				forwarded.push(next);
+				i += 1;
+			}
+		}
+	}
+	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, cmd);
+	const cwd = (typeof cmd.optsWithGlobals === "function" ? cmd.optsWithGlobals() : cmd.opts?.() ?? {}).cwd || process.cwd();
+	await addComponents(packages || [], forwardedOptions, verbose);
+	await fixAstroImports(cwd, 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