bejamas 0.2.0 → 0.2.2

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { BASE_COLORS, extractFrontmatter, getConfig, getProjectInfo, highlighter, logger, parseJsDocMetadata, resolveUiRoot, spinner } from "./utils-DfvCox_O.js";
+import { BASE_COLORS, extractFrontmatter, getConfig, getProjectInfo, getWorkspaceConfig, highlighter, logger, parseJsDocMetadata, resolveUiRoot, spinner } from "./utils-BA01hKci.js";
 import { Command } from "commander";
 import { createRequire } from "module";
 import path from "path";
@@ -527,7 +527,7 @@ async function generateDocs({ cwd, outDir, verbose }) {
 			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-5r1bKyim.js");
+		const mod = await import("./generate-mdx-CPI1OKtC.js");
 		if (typeof mod.runDocsGenerator === "function") await mod.runDocsGenerator();
 		else throw new Error("Failed to load docs generator. Export 'runDocsGenerator' not found.");
 	} catch (err) {
@@ -770,6 +770,116 @@ async function fixAstroImports(cwd, isVerbose) {
 	}
 }
 
+//#endregion
+//#region src/utils/reorganize-components.ts
+/**
+* Fetches a registry item JSON from the registry URL.
+*/
+async function fetchRegistryItem(componentName, registryUrl) {
+	const url = `${registryUrl}/styles/new-york-v4/${componentName}.json`;
+	try {
+		const response = await fetch(url);
+		if (!response.ok) {
+			const fallbackUrl = `${registryUrl}/${componentName}.json`;
+			const fallbackResponse = await fetch(fallbackUrl);
+			if (!fallbackResponse.ok) return null;
+			return await fallbackResponse.json();
+		}
+		return await response.json();
+	} catch {
+		return null;
+	}
+}
+/**
+* Extracts the subfolder name from registry file paths.
+* E.g., "components/ui/avatar/Avatar.astro" → "avatar"
+*/
+function getSubfolderFromPaths(files) {
+	const uiFiles = files.filter((f) => f.type === "registry:ui");
+	if (uiFiles.length < 2) return null;
+	const subfolders = /* @__PURE__ */ new Set();
+	for (const file of uiFiles) {
+		const parts = file.path.split("/");
+		const uiIndex = parts.indexOf("ui");
+		if (uiIndex !== -1 && parts.length > uiIndex + 2) subfolders.add(parts[uiIndex + 1]);
+	}
+	if (subfolders.size === 1) return Array.from(subfolders)[0];
+	if (uiFiles.length > 0) {
+		const firstPath = uiFiles[0].path;
+		const dirname$1 = path$1.dirname(firstPath);
+		const folderName = path$1.basename(dirname$1);
+		if (folderName && folderName !== "ui") return folderName;
+	}
+	return null;
+}
+/**
+* Checks if a path exists.
+*/
+async function pathExists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Reorganizes multi-file components into correct subfolders.
+* Only moves files from FLAT location to subfolder.
+* Does NOT touch files already in subfolders.
+* E.g., moves `uiDir/Avatar.astro` to `uiDir/avatar/Avatar.astro`.
+* Returns info about moved files for display purposes.
+*/
+async function reorganizeComponents(components, uiDir, registryUrl, verbose) {
+	const result = {
+		totalMoved: 0,
+		movedFiles: [],
+		skippedFiles: []
+	};
+	if (!uiDir || components.length === 0) return result;
+	for (const componentName of components) try {
+		const registryItem = await fetchRegistryItem(componentName, registryUrl);
+		if (!registryItem) {
+			if (verbose) logger.info(`[bejamas-ui] Could not fetch registry for ${componentName}, skipping reorganization`);
+			continue;
+		}
+		const subfolder = getSubfolderFromPaths(registryItem.files);
+		if (!subfolder) {
+			if (verbose) logger.info(`[bejamas-ui] ${componentName} is single-file or has no subfolder, skipping`);
+			continue;
+		}
+		const uiFiles = registryItem.files.filter((f) => f.type === "registry:ui");
+		const targetDir = path$1.join(uiDir, subfolder);
+		let movedCount = 0;
+		for (const file of uiFiles) {
+			const filename = path$1.basename(file.path);
+			const flatPath = path$1.join(uiDir, filename);
+			const targetPath = path$1.join(targetDir, filename);
+			if (!await pathExists(flatPath)) continue;
+			if (await pathExists(targetPath)) {
+				try {
+					await fs.unlink(flatPath);
+					result.skippedFiles.push(`${subfolder}/${filename}`);
+					if (verbose) logger.info(`[bejamas-ui] Removed flat duplicate: ${filename} (${subfolder}/${filename} exists)`);
+				} catch {
+					result.skippedFiles.push(`${subfolder}/${filename}`);
+				}
+				continue;
+			}
+			await fs.mkdir(targetDir, { recursive: true });
+			await fs.rename(flatPath, targetPath);
+			movedCount++;
+			result.totalMoved++;
+			result.movedFiles.push(`${subfolder}/${filename}`);
+			if (verbose) logger.info(`[bejamas-ui] Moved ${filename} → ${subfolder}/${filename}`);
+		}
+		if (movedCount > 0 && verbose) logger.info(`[bejamas-ui] Reorganized ${componentName} into ${subfolder}/`);
+	} catch (err) {
+		if (verbose) logger.warn(`[bejamas-ui] Failed to reorganize ${componentName}: ${err}`);
+	}
+	return result;
+}
+
 //#endregion
 //#region src/commands/add.ts
 const DEFAULT_REGISTRY_URL = "https://ui.bejamas.com/r";
@@ -836,16 +946,110 @@ function extractOptionsForShadcn(rawArgv, cmd) {
 	}
 	return forwarded;
 }
-async function addComponents(packages, forwardedOptions, isVerbose) {
+/** Build maps for path rewriting, handling filename collisions */
+async function buildSubfolderMap(components, registryUrl) {
+	const filenameToSubfolders = /* @__PURE__ */ new Map();
+	const componentInfo = /* @__PURE__ */ new Map();
+	for (const componentName of components) {
+		const registryItem = await fetchRegistryItem(componentName, registryUrl);
+		if (!registryItem) continue;
+		const subfolder = getSubfolderFromPaths(registryItem.files);
+		if (!subfolder) continue;
+		const files = [];
+		for (const file of registryItem.files) if (file.type === "registry:ui") {
+			const filename = path$1.basename(file.path);
+			files.push(filename);
+			const subfolders = filenameToSubfolders.get(filename) || [];
+			subfolders.push(subfolder);
+			filenameToSubfolders.set(filename, subfolders);
+		}
+		componentInfo.set(subfolder, {
+			subfolder,
+			files
+		});
+	}
+	const uniqueMap = /* @__PURE__ */ new Map();
+	const sharedFilenames = /* @__PURE__ */ new Set();
+	filenameToSubfolders.forEach((subfolders, filename) => {
+		if (subfolders.length === 1) uniqueMap.set(filename, `${subfolders[0]}/${filename}`);
+		else sharedFilenames.add(filename);
+	});
+	return {
+		uniqueMap,
+		componentInfo,
+		sharedFilenames
+	};
+}
+/**
+* Rewrite file paths to include correct subfolders.
+* Handles shared filenames (like index.ts) by tracking current component context.
+*/
+function rewritePaths(paths, mapResult) {
+	const { uniqueMap, componentInfo, sharedFilenames } = mapResult;
+	let currentSubfolder = null;
+	return paths.map((filePath) => {
+		const filename = path$1.basename(filePath);
+		const parentDir = path$1.basename(path$1.dirname(filePath));
+		const uniqueMapping = uniqueMap.get(filename);
+		if (uniqueMapping) {
+			const expectedSubfolder = path$1.dirname(uniqueMapping);
+			currentSubfolder = expectedSubfolder;
+			if (parentDir !== expectedSubfolder) return `${path$1.dirname(filePath)}/${uniqueMapping}`;
+			return filePath;
+		}
+		if (sharedFilenames.has(filename) && currentSubfolder) {
+			const expectedSubfolder = currentSubfolder;
+			if (parentDir !== expectedSubfolder) return `${path$1.dirname(filePath)}/${expectedSubfolder}/${filename}`;
+		}
+		return filePath;
+	});
+}
+/** Parse shadcn output to extract file lists (stdout has paths, stderr has headers) */
+function parseShadcnOutput(stdout, stderr) {
+	const result = {
+		created: [],
+		updated: [],
+		skipped: []
+	};
+	const cleanStderr = stderr.replace(/\x1b\[[0-9;]*m/g, "");
+	const cleanStdout = stdout.replace(/\x1b\[[0-9;]*m/g, "");
+	const createdMatch = cleanStderr.match(/Created\s+(\d+)\s+file/i);
+	const updatedMatch = cleanStderr.match(/Updated\s+(\d+)\s+file/i);
+	const skippedMatch = cleanStderr.match(/Skipped\s+(\d+)\s+file/i);
+	const createdCount = createdMatch ? parseInt(createdMatch[1], 10) : 0;
+	const updatedCount = updatedMatch ? parseInt(updatedMatch[1], 10) : 0;
+	const skippedCount = skippedMatch ? parseInt(skippedMatch[1], 10) : 0;
+	const allPaths = [];
+	for (const line of cleanStdout.split("\n")) {
+		const match = line.match(/^\s+-\s+(.+)$/);
+		if (match) allPaths.push(match[1].trim());
+	}
+	for (const line of cleanStderr.split("\n")) {
+		const match = line.match(/^\s+-\s+(.+)$/);
+		if (match) {
+			const filePath = match[1].trim();
+			if (!allPaths.includes(filePath)) allPaths.push(filePath);
+		}
+	}
+	let idx = 0;
+	for (let i = 0; i < createdCount && idx < allPaths.length; i++) result.created.push(allPaths[idx++]);
+	for (let i = 0; i < updatedCount && idx < allPaths.length; i++) result.updated.push(allPaths[idx++]);
+	for (let i = 0; i < skippedCount && idx < allPaths.length; i++) result.skipped.push(allPaths[idx++]);
+	return result;
+}
+async function addComponents(packages, forwardedOptions, isVerbose, isSilent, subfolderMapResult) {
 	const runner = await getPackageRunner(process.cwd());
 	const env = {
 		...process.env,
 		REGISTRY_URL: process.env.REGISTRY_URL || DEFAULT_REGISTRY_URL
 	};
+	const autoFlags = [];
+	if (!forwardedOptions.includes("--yes")) autoFlags.push("--yes");
 	const baseArgs = [
 		"shadcn@latest",
 		"add",
 		...packages,
+		...autoFlags,
 		...forwardedOptions
 	];
 	let cmd = "npx";
@@ -861,12 +1065,33 @@ async function addComponents(packages, forwardedOptions, isVerbose) {
 		args = ["-y", ...baseArgs];
 	}
 	if (isVerbose) logger.info(`[bejamas-ui] ${cmd} ${args.join(" ")}`);
+	const registrySpinner = spinner("Checking registry.", { silent: isSilent });
+	registrySpinner.start();
 	try {
-		await execa(cmd, args, {
-			stdio: "inherit",
-			env
+		const result = await execa(cmd, args, {
+			env,
+			input: "n\nn\nn\nn\nn\nn\nn\nn\nn\nn\n",
+			stdout: "pipe",
+			stderr: "pipe",
+			reject: false
 		});
+		registrySpinner.succeed();
+		spinner("Installing components.", { silent: isSilent }).succeed();
+		const stdout = result.stdout || "";
+		const stderr = result.stderr || "";
+		if (isVerbose) {
+			logger.info(`[bejamas-ui] Raw stdout: ${stdout}`);
+			logger.info(`[bejamas-ui] Raw stderr: ${stderr}`);
+		}
+		const parsed = parseShadcnOutput(stdout, stderr);
+		if (result.exitCode !== 0) {
+			if (result.stderr) logger.error(result.stderr);
+			process.exit(result.exitCode);
+		}
+		return parsed;
 	} catch (err) {
+		registrySpinner.fail();
+		logger.error("Failed to add components");
 		process.exit(1);
 	}
 }
@@ -875,8 +1100,60 @@ const add = new Command().name("add").description("Add components via shadcn@lat
 	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);
+	const opts = typeof cmd.optsWithGlobals === "function" ? cmd.optsWithGlobals() : cmd.opts?.() ?? {};
+	const cwd = opts.cwd || process.cwd();
+	const config = await getConfig(cwd);
+	const registryUrl = process.env.REGISTRY_URL || DEFAULT_REGISTRY_URL;
+	let uiDir = config?.resolvedPaths?.ui || "";
+	let uiConfig = config;
+	if (config) {
+		const workspaceConfig = await getWorkspaceConfig(config);
+		if (workspaceConfig?.ui) {
+			uiConfig = workspaceConfig.ui;
+			uiDir = uiConfig.resolvedPaths?.ui || uiDir;
+		}
+	}
+	if (verbose) {
+		logger.info(`[bejamas-ui] cwd: ${cwd}`);
+		logger.info(`[bejamas-ui] uiDir: ${uiDir}`);
+		logger.info(`[bejamas-ui] aliases.ui: ${uiConfig?.aliases?.ui || "not set"}`);
+	}
+	const isSilent = opts.silent || false;
+	const componentsToAdd = packages || [];
+	const totalComponents = componentsToAdd.length;
+	for (let i = 0; i < componentsToAdd.length; i++) {
+		const component = componentsToAdd[i];
+		if (totalComponents > 1 && !isSilent) {
+			logger.break();
+			logger.info(highlighter.info(`[${i + 1}/${totalComponents}]`) + ` Adding ${highlighter.success(component)}...`);
+		}
+		const subfolderMapResult = await buildSubfolderMap([component], registryUrl);
+		const parsed = await addComponents([component], forwardedOptions, verbose, isSilent, subfolderMapResult);
+		let skippedCount = 0;
+		if (uiDir) skippedCount = (await reorganizeComponents([component], uiDir, registryUrl, verbose)).skippedFiles.length;
+		if (!isSilent) {
+			uiDir && path$1.relative(cwd, uiDir);
+			const actuallyCreated = Math.max(0, parsed.created.length - skippedCount);
+			if (actuallyCreated > 0) {
+				const createdPaths = rewritePaths(parsed.created.slice(0, actuallyCreated), subfolderMapResult);
+				logger.success(`Created ${createdPaths.length} file${createdPaths.length > 1 ? "s" : ""}:`);
+				for (const file of createdPaths) logger.log(`  ${highlighter.info("-")} ${file}`);
+			}
+			if (parsed.updated.length > 0) {
+				const uniqueUpdated = Array.from(new Set(parsed.updated));
+				const updatedPaths = rewritePaths(uniqueUpdated, subfolderMapResult);
+				logger.info(`Updated ${updatedPaths.length} file${updatedPaths.length > 1 ? "s" : ""}:`);
+				for (const file of updatedPaths) logger.log(`  ${highlighter.info("-")} ${file}`);
+			}
+			if (skippedCount > 0) logger.info(`Skipped ${skippedCount} file${skippedCount > 1 ? "s" : ""}: (already exists)`);
+			if (parsed.skipped.length > 0) {
+				const skippedPaths = rewritePaths(parsed.skipped, subfolderMapResult);
+				logger.info(`Skipped ${skippedPaths.length} file${skippedPaths.length > 1 ? "s" : ""}: (use --overwrite)`);
+				for (const file of skippedPaths) logger.log(`  ${highlighter.info("-")} ${file}`);
+			}
+			if (actuallyCreated === 0 && parsed.updated.length === 0 && skippedCount === 0 && parsed.skipped.length === 0) logger.info("Already up to date.");
+		}
+	}
 	await fixAstroImports(cwd, verbose);
 });