centoui-cli 1.0.0-alpha.38 → 1.0.0-alpha.40

package/dist/index.mjs

@@ -1,14 +1,13 @@
-#!/usr/bin/env node
 import { defineCommand, runMain } from "citty";
-import { cancel, confirm, group, intro, isCancel, log, note, outro, tasks, text } from "@clack/prompts";
-import { dirname, join } from "pathe";
+import { cancel, confirm, group, intro, isCancel, log, outro, tasks, text } from "@clack/prompts";
+import { join } from "pathe";
+import { loadConfig } from "c12";
 import fsExtra from "fs-extra";
 import { addDependency, removeDependency } from "nypm";
-import { loadConfig } from "c12";
 //#endregion
 //#region src/constants.ts
 /** CentoUI current package version, sourced directly from package.json. */
-const VERSION = "1.0.0-alpha.38";
+const VERSION = "1.0.0-alpha.40";
 /** File name for the user-side CentoUI config (created by `centoui init`). */
 const CONFIG_FILE_NAME = "centoui.config.ts";
 /**
@@ -18,24 +17,7 @@ const CONFIG_FILE_NAME = "centoui.config.ts";
 * The path ends at `src/` so that registry and component paths from the
 * registry (e.g. `components/button/button.vue`) can be appended directly.
 */
-const CORE_SRC_BASE_URL = `https://raw.githubusercontent.com/favorodera/centoui/refs/tags/v${VERSION}/packages/core/src`;
-/** Full URL to the registry index file that lists every available component. */
-const REGISTRY_INDEX_URL = `${`${CORE_SRC_BASE_URL}/registry`}/index.json`;
-/**
-* Full URL to the CentoUI CSS theme file.
-* This file is written to the user's project during `centoui init`.
-*/
-const THEME_CSS_URL = `${CORE_SRC_BASE_URL}/defaults/centoui.css`;
-/**
-* Full URL to the utils file.
-* This file is written to the user's project during `centoui init`.
-*/
-const UTILS_FILE_URL = `${CORE_SRC_BASE_URL}/defaults/utils.ts`;
-/**
-* Full URL to the default values file for the CentoUI config.
-* The contents of this file are written to the user's project during `centoui init`.
-*/
-const CONFIG_DEFAULTS_URL = `${CORE_SRC_BASE_URL}/defaults/config.ts`;
+const BASE_URL = `https://raw.githubusercontent.com/favorodera/centoui/refs/tags/v${VERSION}/packages/core/src`;
 /**
 * HTTP headers required when fetching raw content from the GitHub API.
 * These ensure we get the raw file bytes, not GitHub's HTML wrapper.
@@ -45,701 +27,434 @@ const GITHUB_RAW_FETCH_HEADERS = {
 	"X-GitHub-Api-Version": "2026-03-10"
 };
 //#endregion
-//#region src/utils/package-utils.ts
+//#region src/utils/network.ts
 /**
-* Installs any packages from `requiredPackages` that are missing from — or at
-* a different version than what is listed in — the project's `package.json`.
-*
-* Already-satisfied packages are skipped entirely to avoid unnecessary network
-* traffic and lockfile churn. The package manager is auto-detected from
-* lockfiles by nypm (npm / pnpm / yarn / bun).
-*
-* @param requiredPackages - Map of `packageName → semver version range`.
-* @param cwd - Absolute path to the project root (must contain `package.json`).
-* @param onProgress - Optional callback fired before each `addDependency` call
-*                     with a `"[n/total] package@version"` string.
-* @returns Human-readable summary (e.g. `"Installed 3 package(s)"`).
-* @throws If reading `package.json` or running the package manager fails.
+* Sends a network request to the CentoUI core package on GitHub.
+* @param path The relative path to the file from the base URL (i.e. core/src).
+* @param responseFormat The format of the response.
+* @param init The request options.
+* @returns The response from the server.
+* @throws If the network request fails or the server returns a non-2xx status.
 */
-async function installMissingPackages(requiredPackages, cwd, onProgress) {
-	if (Object.keys(requiredPackages).length === 0) return "No packages to install";
-	const packageJson = await fsExtra.readJson(join(cwd, "package.json")).catch(() => ({}));
-	const alreadyInstalled = {
-		...packageJson.dependencies,
-		...packageJson.devDependencies
+async function sendNetworkRequest(path, responseFormat = "text", init) {
+	const url = `${BASE_URL}${path}`;
+	const resolvedInit = {
+		...init,
+		headers: {
+			...GITHUB_RAW_FETCH_HEADERS,
+			...init?.headers
+		}
 	};
-	const packagesToInstall = Object.entries(requiredPackages).filter(([name]) => !(name in alreadyInstalled)).map(([name, version]) => `${name}@${version}`);
-	if (packagesToInstall.length === 0) return "All packages already up to date";
+	let response;
 	try {
-		for (const [index, pkg] of packagesToInstall.entries()) {
-			onProgress?.(`[${index + 1}/${packagesToInstall.length}] ${pkg}`);
-			await addDependency(pkg, {
-				cwd,
-				silent: true
-			});
-		}
+		response = await fetch(url, resolvedInit);
 	} catch (error) {
-		throw new Error(`[installMissingPackages] Failed to install packages: ${error}`);
+		throw new Error("Network request failed", { cause: error });
+	}
+	if (!response.ok) throw new Error(`Server responded with ${response.status} ${response.statusText} (URL: ${url})`);
+	let resolvedResponse;
+	switch (responseFormat) {
+		case "json":
+			resolvedResponse = await response.json();
+			break;
+		case "text":
+			resolvedResponse = await response.text();
+			break;
 	}
-	return `Installed ${packagesToInstall.length} package(s)`;
+	return resolvedResponse;
 }
+//#endregion
+//#region src/utils/config.ts
 /**
-* Removes packages that were used by a component being uninstalled, but only
-* if those packages are not still required by other remaining components.
-*
-* Skips any package that appears in `packagesStillNeeded` so that shared
-* dependencies are never removed prematurely.
-*
-* @param packagesToConsider - Packages belonging to the component being removed.
-* @param packagesStillNeeded - Union of `packageDeps` from all other installed components.
-* @param cwd - Absolute path to the project root.
-* @param onProgress - Optional callback fired before each `removeDependency` call.
-* @returns Human-readable summary (e.g. `"Removed 2 package(s)"`).
-* @throws If the package manager fails to remove a dependency.
+* Loads the user's CentoUI configuration from `centoui.config.ts`.
+* @param cwd Absolute path to the project root.
+* @returns The user's configuration.
+* @throws If `centoui.config.ts` is not found.
 */
-async function removeOrphanedPackages(packagesToConsider, packagesStillNeeded, cwd, onProgress) {
-	const packagesToRemove = Object.keys(packagesToConsider).filter((name) => !(name in packagesStillNeeded));
-	if (packagesToRemove.length === 0) return "No packages to remove";
-	try {
-		for (const [index, pkg] of packagesToRemove.entries()) {
-			onProgress?.(`[${index + 1}/${packagesToRemove.length}] ${pkg}`);
-			await removeDependency(pkg, {
-				cwd,
-				silent: true
-			});
-		}
-	} catch (error) {
-		throw new Error(`[removeOrphanedPackages] Failed to remove packages: ${error}`);
-	}
-	return `Removed ${packagesToRemove.length} package(s)`;
+async function loadConfig$1(cwd) {
+	const { config, configFile } = await loadConfig({
+		cwd,
+		name: "centoui"
+	});
+	if (!configFile) throw new Error(`${CONFIG_FILE_NAME} not found in ${cwd}. Run \`centoui init\` first.`);
+	return config;
 }
 /**
-* Validates that a value is a non-empty string usable as a file-system path.
-*
-* Intended as a `validate` callback for `@clack/prompts` text inputs.
-*
-* @param value - The raw value from the prompt.
-* @returns An error message string if invalid, or `undefined` if valid.
+* Builds the user's CentoUI configuration file content.
+* @param choices The user's configuration choices.
+* @returns The file content.
+* @throws If building fails.
 */
-function validateNonEmptyPath(value) {
-	if (typeof value !== "string") return "Expected a string path";
-	if (value.trim().length === 0) return "Path cannot be empty";
+async function buildUserConfig(choices) {
+	try {
+		let cleanedContent = (await sendNetworkRequest("/config.ts")).replaceAll(/^import\s+.*$/gm, "").replace(/^\s*export\s+default\s+/, "").replace(/\s+satisfies\s+[^}]*$/, "").trim();
+		const firstBrace = cleanedContent.indexOf("{");
+		const lastBrace = cleanedContent.lastIndexOf("}");
+		cleanedContent = cleanedContent.slice(firstBrace + 1, lastBrace).replace(/^\n/, "").replace(/\n\s*$/, "");
+		return `import { defineConfig } from 'centoui'
+
+export default defineConfig({
+  componentsDir: '${choices.componentsDir}',
+  themeFilePath: '${choices.themeFilePath}',
+${cleanedContent}
+})`;
+	} catch (error) {
+		throw new Error("Failed to build user config", { cause: error });
+	}
 }
 //#endregion
-//#region src/utils/file-system-utils.ts
+//#region src/utils/file-system.ts
 /**
-* Converts a registry-relative component file path into the absolute destination path
-* inside the user's project.
-*
-* Registry component file paths always begin with `components/` (e.g.
-* `"components/button/button.vue"`). This function strips that leading segment
-* and joins the remainder with the user's configured components directory so
-* that `"components/button/button.vue"` becomes, for example,
-* `"/home/user/my-app/src/components/centoui/button/button.vue"`.
-*
-* @param registryComponentFilePath - Path as it appears in the component's registry entry
-*                           (always starts with `"components/"`).
-* @param config - The loaded CentoUI project configuration.
-* @param cwd - Absolute path to the project root.
-* @returns Absolute destination path for the file in the user's project.
-*
-* @example
-* // config.componentsDir = 'src/components/centoui', cwd = '/home/user/my-app'
-* mapComponentsRegistryPathToProjectDest('components/button/button.vue', config, cwd)
-* // → '/home/user/my-app/src/components/centoui/button/button.vue'
+* Writes content to a file, creating parent directories if they don't exist.
+* @param path The file path to write to.
+* @param content The content to write to the file.
+* @throws If the file cannot be written to.
 */
-function mapComponentsRegistryPathToProjectDest(registryComponentFilePath, config, cwd) {
-	const pathWithoutRegistryPrefix = registryComponentFilePath.replace(/^components\//, "");
-	return join(cwd, config.componentsDir, pathWithoutRegistryPrefix);
+async function writeToFile(path, content) {
+	try {
+		await fsExtra.outputFile(path, content, "utf8");
+	} catch (error) {
+		throw new Error(`Failed to write ${path}`, { cause: error });
+	}
 }
 /**
-* Writes `content` to `filePath`, creating every missing parent directory first.
-*
-* This is the standard way to write any file in the CLI — it ensures the
-* target directory tree exists so callers don't have to `mkdir` manually.
-*
-* @param filePath - Absolute path where the file should be written.
-* @param content - UTF-8 string content to write.
-* @throws If the directory cannot be created or the file cannot be written.
+* Creates a directory and any necessary parent directories.
+* @param path The directory path to create.
+* @throws If the directory cannot be created.
 */
-async function writeFileWithDirs(filePath, content) {
+async function createDirectory(path) {
 	try {
-		await fsExtra.mkdir(dirname(filePath), { recursive: true });
-		await fsExtra.writeFile(filePath, content, "utf8");
+		await fsExtra.ensureDir(path);
 	} catch (error) {
-		throw new Error(`[writeFileWithDirs] Failed to write "${filePath}": ${error}`);
+		throw new Error(`Failed to create directory ${path}`, { cause: error });
 	}
 }
 /**
 * Prompts the user to confirm before overwriting an existing path.
-*
-* If `path` does not yet exist, returns `true` immediately without showing
-* any prompt — nothing to overwrite, safe to proceed.
-*
-* If the user cancels the prompt (e.g. Ctrl+C), the process exits cleanly
-* with a cancellation message rather than throwing.
-*
-* @param label - Human-readable name shown in the prompt (e.g. `"centoui.config.ts"`).
-* @param path - Absolute path to the file or directory to potentially overwrite.
-* @returns `true` if the caller should write/overwrite, `false` if the user declined.
+* @param path The absolute path to the file or directory to potentially overwrite.
+* @returns Whether the user wants to overwrite the file.
 */
-async function confirmOverwriteIfExists(label, path) {
+async function confirmOverwrite(path) {
 	if (!await fsExtra.pathExists(path)) return true;
 	const answer = await confirm({
-		message: `"${label}" already exists. Overwrite?`,
-		initialValue: false
+		initialValue: false,
+		message: `${path} already exists. Overwrite?`
 	});
 	if (isCancel(answer)) {
-		cancel("Operation cancelled.");
+		cancel("Operation cancelled by user.");
 		process.exit(0);
 	}
 	return answer;
 }
 //#endregion
-//#region src/utils/config-utils.ts
+//#region src/utils/package.ts
 /**
-* Loads and returns the user's CentoUI configuration from `centoui.config.ts` using c12.
-*
-* @param cwd - Absolute path to the project root.
-* @returns The default export of `centoui.config.ts` cast as {@link CentoUIConfig}.
-* @throws If `centoui.config.ts` is not found — instructs the user to run `centoui init`.
-* @throws If the file exists but cannot be imported or does not export a default value.
+* Installs a dependency using nypm.
+* @param name Dependency name.
+* @param version Dependency semver version.
+* @param cwd Current working directory.
+* @returns Status message.
 */
-async function loadCentoUIConfig(cwd) {
-	const { config, configFile } = await loadConfig({
-		name: "centoui",
-		cwd
-	});
-	if (!configFile) throw new Error(`[loadCentoUIConfig] "${CONFIG_FILE_NAME}" not found in "${cwd}". Run \`centoui init\` first.`);
-	return config;
-}
-/**
-* Fetches the raw content of the default CentoUI config file from GitHub.
-*
-* This file contains the default icon mappings and other shared defaults
-* that are merged into the user's generated config.
-*
-* @returns Raw UTF-8 content of the default config file.
-* @throws If the network request fails or the server returns a non-2xx status.
-*/
-async function fetchDefaultConfig() {
-	let response;
+async function installDependency(name, version, cwd) {
 	try {
-		response = await fetch(CONFIG_DEFAULTS_URL, { headers: GITHUB_RAW_FETCH_HEADERS });
+		const packageJson = await fsExtra.readJson(join(cwd, "package.json")).catch(() => ({}));
+		if (name in {
+			...packageJson?.dependencies,
+			...packageJson?.devDependencies
+		}) return `${name} is already installed.`;
+		const target = `${name}@${version}`;
+		await addDependency(target, {
+			cwd,
+			silent: true
+		});
+		return `${target} installed.`;
 	} catch (error) {
-		throw new Error(`[fetchDefaultConfigContent] Network request for default config failed: ${error}`);
+		throw new Error(`Failed to install ${name}`, { cause: error });
 	}
-	if (!response.ok) throw new Error(`[fetchDefaultConfigContent] Server returned ${response.status} ${response.statusText} (URL: ${CONFIG_DEFAULTS_URL})`);
-	return response.text();
-}
-/**
-* Extracts the inner config object from the default config file content.
-*
-* Strips the `export default`, `satisfies` clause, and outer braces,
-* returning just the inner properties as a raw string.
-*
-* @example
-* // Input:
-* // export default {
-* //   icons: { check: 'lucide:check' },
-* // } satisfies Pick<CentoUIConfig, 'icons'>
-* // Output:
-* // "  icons: { check: 'lucide:check' },"
-*
-* @param fileContent - The full source of the default config file.
-* @returns The inner config body, or an empty string if no object is found.
-*/
-function extractInnerConfigContent(fileContent) {
-	let cleanedConfigContent = fileContent.replace(/^import\s+.*$/gm, "");
-	cleanedConfigContent = cleanedConfigContent.replace(/^\s*export\s+default\s+/, "");
-	cleanedConfigContent = cleanedConfigContent.replace(/\s+satisfies\s+[^}]*$/, "");
-	cleanedConfigContent = cleanedConfigContent.trim();
-	const firstBrace = cleanedConfigContent.indexOf("{");
-	const lastBrace = cleanedConfigContent.lastIndexOf("}");
-	if (firstBrace === -1 || lastBrace === -1 || lastBrace <= firstBrace) return "";
-	return cleanedConfigContent.slice(firstBrace + 1, lastBrace).replace(/^\n/, "").replace(/\n\s*$/, "");
 }
 /**
-* Generates the content of a default `centoui.config.ts` file.
-*
-* The generated file uses `defineConfig` so IDEs can provide type-checking
-* and autocompletion on the config object. It pre-fills common icon mappings
-* for the built-in Lucide icon set.
-*
-* @param themeFilePath - Relative path (from project root) where the CSS theme file lives.
-* @param componentsDir - Relative path (from project root) where components will be installed.
-* @returns A string containing the complete TypeScript source for the config file.
-*/
-/**
-* Generates the content of a user's default `centoui.config.ts` file.
-*
-* Fetches the default config from GitHub to get the latest default config values (icon mappings, etc.),
-* then merges them with the user-provided paths. The generated file uses
-* `defineConfig` so IDEs can provide type-checking and autocompletion.
-*
-* @param themeFilePath - Relative path (from project root) where the CSS theme file lives.
-* @param componentsDir - Relative path (from project root) where components will be installed.
-* @param utilsFilePath - Relative path (from project root) where the utils file lives.
-* @returns A string containing the complete TypeScript source for the config file.
+* Uninstalls a dependency using nypm.
+* @param name Dependency name.
+* @param cwd Current working directory.
+* @returns Status message.
 */
-async function buildUserDefaultConfigFileContent(themeFilePath, componentsDir, utilsFilePath) {
-	return `import { defineConfig } from 'centoui'
-
-export default defineConfig({
-  componentsDir: '${componentsDir}',
-  themeFilePath: '${themeFilePath}',
-  utilsFilePath: '${utilsFilePath}',
-${extractInnerConfigContent(await fetchDefaultConfig())}
-})
-`;
+async function uninstallDependency(name, cwd) {
+	try {
+		const packageJson = await fsExtra.readJson(join(cwd, "package.json")).catch(() => ({}));
+		if (!(name in {
+			...packageJson?.dependencies,
+			...packageJson?.devDependencies
+		})) return `${name} is not installed.`;
+		await removeDependency(name, {
+			cwd,
+			silent: true
+		});
+		return `${name} uninstalled.`;
+	} catch (error) {
+		throw new Error(`Failed to uninstall ${name}`, { cause: error });
+	}
 }
 //#endregion
-//#region src/utils/registry-utils.ts
+//#region src/utils/registry.ts
 /** In-process cache so the registry is only fetched once per CLI invocation. */
-let cachedRegistry = null;
+let cachedRegistry;
 /**
-* Fetches the complete component registry (`index.json`) from GitHub, caching
-* the result in memory for the lifetime of the process.
-*
-* Every other registry utility calls this internally, so the network round-trip
-* only happens once regardless of how many components are being installed.
-*
-* @returns The full registry object including globals and all component entries.
-* @throws If the network request fails or the server returns a non-2xx status.
+* Fetches the component registry (`index.json`) from GitHub and caches it.
+* @returns The registry including npm dependencies and components.
 */
-async function fetchFullRegistry() {
+async function fetchRegistry() {
 	if (cachedRegistry) return cachedRegistry;
-	let response;
-	try {
-		response = await fetch(REGISTRY_INDEX_URL, { headers: GITHUB_RAW_FETCH_HEADERS });
-	} catch (error) {
-		throw new Error(`[fetchFullRegistry] Network request to registry failed: ${error}`);
-	}
-	if (!response.ok) throw new Error(`[fetchFullRegistry] Registry responded with ${response.status} ${response.statusText} (URL: ${REGISTRY_INDEX_URL})`);
-	cachedRegistry = await response.json();
-	return cachedRegistry;
+	const registry = await sendNetworkRequest("/registry/index.json", "json");
+	cachedRegistry = registry;
+	return registry;
 }
 /**
-* Recursively resolves a component and every one of its transitive
-* `componentDeps` into a flat map of `componentName → registry entry`.
-*
-* The traversal is depth-first and guards against circular dependencies via
-* the `visited` set, so each component appears in the result exactly once.
-*
-* @param componentName - Root component name to start resolving from.
-* @param registry - Pre-fetched registry (pass the result of {@link fetchFullRegistry}).
-* @param visited - Internal visited set used to prevent infinite loops;
-*                  callers should omit this — it defaults to an empty set.
-* @returns A `Map<componentName, ComponentRegistry>` covering the full tree.
-* @throws If any component in the tree is not found in the registry.
+* Recursively resolves a component and its dependencies into a map.
+* @param name Component name.
+* @param registry The component registry.
+* @param result Internal accumulator map.
+* @returns Map of resolved component names to their entries.
+* @throws If any component is not found.
 */
-function resolveComponentWithDependencies(componentName, registry, visited = /* @__PURE__ */ new Set()) {
-	const result = /* @__PURE__ */ new Map();
-	if (visited.has(componentName)) return result;
-	visited.add(componentName);
-	const entry = registry.components.find((component) => component.name === componentName);
-	if (!entry) throw new Error(`[resolveComponentWithDependencies] Component "${componentName}" not found in registry.`);
-	result.set(componentName, entry);
-	for (const dep of entry?.componentDeps || []) for (const [depName, depEntry] of resolveComponentWithDependencies(dep, registry, visited)) result.set(depName, depEntry);
+function resolveComponent(name, registry, result = /* @__PURE__ */ new Map()) {
+	if (result.has(name)) return result;
+	const entry = registry.components.find((component) => component.name === name);
+	if (!entry) throw new Error(`Component ${name} not found in registry.`);
+	result.set(name, entry);
+	for (const component of entry.componentDependencies || []) resolveComponent(component, registry, result);
 	return result;
 }
+//#endregion
+//#region src/commands/add.ts
 /**
-* Fetches the raw source content of a file referenced in a component's
-* registry entry.
-*
-* Registry file paths (e.g. `"components/button/button.vue"`) are relative
-* to `packages/core/src/`, which is already the base of {@link CORE_SRC_BASE_URL}.
-* This function simply appends the path and downloads the content.
-*
-* @param registryFilePath - Path as it appears in the component's `files` array
-*                           (e.g. `"components/button/button.vue"`).
-* @returns Raw UTF-8 content of the file.
-* @throws If the network request fails or the server returns a non-2xx status.
-*/
-async function fetchRegistryFileContent(registryFilePath) {
-	const url = `${CORE_SRC_BASE_URL}/${registryFilePath}`;
-	let response;
-	try {
-		response = await fetch(url, { headers: GITHUB_RAW_FETCH_HEADERS });
-	} catch (error) {
-		throw new Error(`[fetchRegistryFileContent] Network request failed for "${registryFilePath}": ${error}`);
-	}
-	if (!response.ok) throw new Error(`[fetchRegistryFileContent] Server returned ${response.status} ${response.statusText} for "${url}"`);
-	return response.text();
-}
-/**
-* Fetches the raw content of the CentoUI CSS theme file from GitHub.
-*
-* This is the file written to the user's project during `centoui init` and
-* contains all CSS custom properties and base styles for every component.
-*
-* @returns Raw UTF-8 content of the theme CSS file.
-* @throws If the network request fails or the server returns a non-2xx status.
-*/
-async function fetchThemeCSSContent() {
-	let response;
-	try {
-		response = await fetch(THEME_CSS_URL, { headers: GITHUB_RAW_FETCH_HEADERS });
-	} catch (error) {
-		throw new Error(`[fetchThemeCSSContent] Network request for theme CSS failed: ${error}`);
-	}
-	if (!response.ok) throw new Error(`[fetchThemeCSSContent] Server returned ${response.status} ${response.statusText} (URL: ${THEME_CSS_URL})`);
-	return response.text();
-}
-/**
-* Fetches the raw content of the CentoUI utils file from GitHub.
-*
-* This is the file written to the user's project during `centoui init` and
-* contains all global utils for every component.
-*
-* @returns Raw UTF-8 content of the utils file.
-* @throws If the network request fails or the server returns a non-2xx status.
+* Installs one or more components and their full transitive dependency trees from the registry into the user's project.
+* @returns The Citty command definition that executes the 'add' CLI process.
 */
-async function fetchUtilsFileContent() {
-	let response;
-	try {
-		response = await fetch(UTILS_FILE_URL, { headers: GITHUB_RAW_FETCH_HEADERS });
-	} catch (error) {
-		throw new Error(`[fetchUtilsFileContent] Network request for utils file failed: ${error}`);
-	}
-	if (!response.ok) throw new Error(`[fetchUtilsFileContent] Server returned ${response.status} ${response.statusText} (URL: ${UTILS_FILE_URL})`);
-	return response.text();
+async function add() {
+	return defineCommand({
+		meta: {
+			description: "Add one or more components to your project",
+			name: "add"
+		},
+		args: {},
+		run: async ({ args }) => {
+			const cwd = process.cwd();
+			intro("CentoUI — Add components!");
+			const requestedComponents = args._;
+			if (requestedComponents.length === 0) throw new Error("No components specified. Usage: centoui add <component> [component...]");
+			log.step("Loading config.");
+			const config = await loadConfig$1(cwd);
+			log.step("Fetching registry.");
+			const registry = await fetchRegistry();
+			log.step("Resolving components");
+			const resolvedComponents = /* @__PURE__ */ new Map();
+			for (const requested of requestedComponents) {
+				const resolvedTree = resolveComponent(requested, registry);
+				for (const [name, entry] of resolvedTree) resolvedComponents.set(name, entry);
+			}
+			const writeDecisions = /* @__PURE__ */ new Map();
+			for (const [name] of resolvedComponents) {
+				const shouldWrite = await confirmOverwrite(join(cwd, config.componentsDir, name));
+				writeDecisions.set(name, shouldWrite);
+			}
+			const npmDependenciesToInstall = {};
+			for (const [name, entry] of resolvedComponents) if (writeDecisions.get(name)) Object.assign(npmDependenciesToInstall, entry.npmDependencies);
+			await tasks([...[...resolvedComponents.entries()].filter(([name]) => writeDecisions.get(name)).map(([name, entry]) => {
+				return {
+					task: async (message) => {
+						message(`Installing ${name}.`);
+						for (const path of entry.files) {
+							message(`Fetching contents from registry.`);
+							const content = await sendNetworkRequest(`/components/${path}`);
+							const destination = join(cwd, config.componentsDir, path);
+							message("Writing to disk.");
+							await writeToFile(destination, content);
+						}
+						return `${name} component installed!`;
+					},
+					title: `Installing ${name}`
+				};
+			}), {
+				enabled: Object.keys(npmDependenciesToInstall).length > 0,
+				task: async (message) => {
+					for (const [name, version] of Object.entries(npmDependenciesToInstall)) {
+						message(`Installing ${name}.`);
+						await installDependency(name, version, cwd);
+					}
+					return "Dependencies installed!";
+				},
+				title: "Installing dependencies"
+			}]);
+			outro("Installation Complete!");
+		}
+	});
 }
 //#endregion
 //#region src/commands/init.ts
 /**
-* Command: `centoui init`
-*
 * Bootstraps a new CentoUI project in the current working directory.
-*
-* Flow:
-*  1. Prompt the user for the components directory, theme CSS file path, and utils file path.
-*  2. Ask upfront whether to overwrite the config file, theme CSS, components directory paths if they already exist.
-*  3. Write the config file, fetch and write the theme CSS, prepare the
-*     components directory, and install global npm dependencies.
+* @returns The Citty command definition that executes the 'init' CLI process.
 */
 function init() {
 	return defineCommand({
 		meta: {
-			name: "init",
-			description: "Initialize a new CentoUI project"
+			description: "Initialize a new CentoUI project",
+			name: "init"
 		},
-		async run() {
-			try {
-				const cwd = process.cwd();
-				intro("CentoUI — Initialize project");
-				const directories = await group({
-					componentDir: () => text({
-						message: "Directory to store components",
-						initialValue: "src/components/centoui",
-						validate: validateNonEmptyPath
-					}),
-					themeFilePath: () => text({
-						message: "Path for the theme CSS file",
-						initialValue: "src/assets/css/centoui.css",
-						validate: validateNonEmptyPath
-					}),
-					utilsFilePath: () => text({
-						message: "Path for the utils file (written on demand)",
-						initialValue: "src/utils/centoui-utils.ts",
-						validate: validateNonEmptyPath
-					})
-				}, { onCancel: () => {
-					cancel("Initialization cancelled.");
-					process.exit(0);
-				} });
-				const configPath = join(cwd, CONFIG_FILE_NAME);
-				const themePath = join(cwd, directories.themeFilePath);
-				const componentsPath = join(cwd, directories.componentDir);
-				const shouldWriteConfig = await confirmOverwriteIfExists(CONFIG_FILE_NAME, configPath);
-				const shouldWriteTheme = await confirmOverwriteIfExists(directories.themeFilePath, themePath);
-				const shouldWriteComponentsDir = await confirmOverwriteIfExists(directories.componentDir, componentsPath);
-				let registry;
-				await tasks([
-					{
-						title: "Fetching config defaults",
-						task: async () => {
-							if (!shouldWriteConfig) return `Skipped — "${CONFIG_FILE_NAME}" already exists`;
-							await writeFileWithDirs(configPath, await buildUserDefaultConfigFileContent(directories.themeFilePath, directories.componentDir, directories.utilsFilePath));
-							return `${CONFIG_FILE_NAME} written`;
-						}
+		run: async () => {
+			const cwd = process.cwd();
+			intro("CentoUI — Initialize project!");
+			const choices = await group({
+				componentsDir: () => text({
+					initialValue: "src/components/centoui",
+					message: "Directory to store components."
+				}),
+				themeFilePath: () => text({
+					initialValue: "src/assets/css/centoui.css",
+					message: "Path for the theme CSS file."
+				})
+			}, { onCancel: () => {
+				cancel("Project initialization cancelled.");
+				process.exit(0);
+			} });
+			const configPath = join(cwd, CONFIG_FILE_NAME);
+			const themePath = join(cwd, choices.themeFilePath);
+			const componentsPath = join(cwd, choices.componentsDir);
+			const shouldWriteConfig = await confirmOverwrite(CONFIG_FILE_NAME);
+			const shouldWriteTheme = await confirmOverwrite(choices.themeFilePath);
+			const shouldWriteComponentsDir = await confirmOverwrite(choices.componentsDir);
+			let registry;
+			await tasks([
+				{
+					enabled: shouldWriteConfig,
+					task: async (message) => {
+						message("Building config content.");
+						const userConfigContent = await buildUserConfig(choices);
+						message("Writing to disk.");
+						await writeToFile(configPath, userConfigContent);
+						return "Config created!";
 					},
-					{
-						title: "Fetching theme CSS",
-						task: async () => {
-							if (!shouldWriteTheme) return `Skipped — "${directories.themeFilePath}" already exists`;
-							await writeFileWithDirs(themePath, await fetchThemeCSSContent());
-							return `${directories.themeFilePath} written`;
-						}
+					title: "Creating config."
+				},
+				{
+					enabled: shouldWriteTheme,
+					task: async (message) => {
+						message("Fetching theme from registry.");
+						const themeFileContent = await sendNetworkRequest("/theme.css");
+						message("Writing to disk.");
+						await writeToFile(themePath, themeFileContent);
+						return "Theme created!";
 					},
-					{
-						title: "Preparing components directory",
-						task: async () => {
-							if (!shouldWriteComponentsDir) return `Skipped — "${directories.componentDir}" already exists`;
-							await fsExtra.emptyDir(componentsPath);
-							return `${directories.componentDir} ready`;
-						}
+					title: "Creating theme."
+				},
+				{
+					enabled: shouldWriteComponentsDir,
+					task: async (message) => {
+						message("Writing to disk.");
+						await createDirectory(componentsPath);
+						return "Components directory ready!";
+					},
+					title: "Preparing components directory."
+				},
+				{
+					task: async () => {
+						registry = await fetchRegistry();
+						return "Registry loaded!";
 					},
-					{
-						title: "Fetching registry",
-						task: async () => {
-							registry = await fetchFullRegistry();
-							return "Registry loaded";
+					title: "Loading registry."
+				},
+				{
+					task: async (message) => {
+						for (const [name, version] of Object.entries(registry.npmDependencies)) {
+							message(`Installing ${name}.`);
+							await installDependency(name, version, cwd);
 						}
+						return "Dependencies installed!";
 					},
-					{
-						title: "Installing global dependencies",
-						task: async (message) => installMissingPackages(registry.globals.packageDeps, cwd, message)
-					}
-				]);
-				note([
-					`Config     > ${configPath}`,
-					`Theme      > ${themePath}`,
-					`Components > ${componentsPath}`,
-					"",
-					"Run 'centoui add button' to install your first component."
-				].filter(Boolean).join("\n"), "CentoUI initialized");
-				outro("All set!");
-			} catch (error) {
-				log.error(`Initialization failed: ${error}`);
-				process.exit(1);
-			}
+					title: "Installing dependencies."
+				}
+			]);
+			outro("Initialization Complete!");
 		}
 	});
 }
 //#endregion
-//#region src/utils/components-utils.ts
-/**
-* Scans the configured components directory and returns a sorted list of
-* installed component names.
-*
-* Each direct subdirectory of `config.componentsDir` is treated as one
-* installed component. Non-directory entries (loose files) are ignored.
-*
-* @param config - The loaded CentoUI project configuration.
-* @param cwd - Absolute path to the project root.
-* @returns Sorted array of installed component names, or an empty array if
-*          the components directory does not exist yet.
-* @throws If the directory exists but cannot be read.
-*/
-async function listInstalledComponentNames(config, cwd) {
-	const componentsDir = join(cwd, config.componentsDir);
-	try {
-		if (!await fsExtra.pathExists(componentsDir)) return [];
-		return (await fsExtra.readdir(componentsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
-	} catch (error) {
-		throw new Error(`[listInstalledComponentNames] Failed to read components directory "${componentsDir}": ${error}`);
-	}
-}
-/**
-* Returns the absolute path to a component's installation directory inside
-* the user's project.
-*
-* The directory may or may not exist yet — this function does not check.
-* Use {@link checkIsComponentInstalled} if you need to verify existence.
-*
-* @param componentName - The component name in kebab-case (e.g. `"button"`).
-* @param config - The loaded CentoUI project configuration.
-* @param cwd - Absolute path to the project root.
-*/
-function resolveComponentInstallDir(componentName, config, cwd) {
-	return join(cwd, config.componentsDir, componentName);
-}
+//#region src/utils/components.ts
 /**
-* Checks whether a component is currently installed by testing for the
-* existence of its installation directory.
-*
-* @param componentName - The component name in kebab-case (e.g. `"button"`).
-* @param config - The loaded CentoUI project configuration.
-* @param cwd - Absolute path to the project root.
-* @returns `true` if the component directory exists, `false` otherwise.
+* Scans the components directory to determine which CentoUI components are installed.
+* @param config User's CentoUI configuration.
+* @param cwd Absolute path to the project root.
+* @returns Sorted array of installed component names.
+* @throws If the components directory cannot be read.
 */
-async function checkIsComponentInstalled(componentName, config, cwd) {
-	const componentInstallDir = resolveComponentInstallDir(componentName, config, cwd);
+async function getInstalledComponents(config, cwd) {
 	try {
-		return fsExtra.pathExists(componentInstallDir);
+		const componentsDir = join(cwd, config.componentsDir);
+		return (await fsExtra.readdir(componentsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).toSorted();
 	} catch (error) {
-		throw new Error(`[checkIsComponentInstalled] Failed to check if component "${componentName}" is installed: ${error}`);
+		throw new Error("Failed to read components directory", { cause: error });
 	}
 }
 //#endregion
-//#region src/commands/add.ts
-/**
-* Command: `centoui add <component> [component...]`
-*
-* Installs one or more components — and their full transitive dependency trees
-* — from the registry into the user's project.
-*
-* Flow:
-*  1. Resolve the full dependency tree for every requested component.
-*  2. Ask the user upfront whether to overwrite any that already exist.
-*  3. Fetch and write the source files for components the user approved.
-*  4. Fetch and write the utils file if it doesn't exist but is required by the components.
-*  5. Install any npm packages required by the components being written.
-*/
-function add() {
-	return defineCommand({
-		meta: {
-			name: "add",
-			description: "Add one or more components to your project"
-		},
-		args: {},
-		async run({ args }) {
-			try {
-				const cwd = process.cwd();
-				const requestedNames = args._;
-				intro("CentoUI — Add components");
-				if (requestedNames.length === 0) throw new Error("No components specified. Usage: centoui add <component> [component...]");
-				const config = await loadCentoUIConfig(cwd);
-				const registry = await fetchFullRegistry();
-				const allComponents = /* @__PURE__ */ new Map();
-				for (const name of requestedNames) try {
-					const tree = resolveComponentWithDependencies(name, registry);
-					for (const [depName, depEntry] of tree) allComponents.set(depName, depEntry);
-				} catch (error) {
-					throw new Error(`Failed to resolve "${name}": ${error}`);
-				}
-				const writeDecisions = /* @__PURE__ */ new Map();
-				for (const [name] of allComponents) {
-					const shouldWrite = await confirmOverwriteIfExists(name, resolveComponentInstallDir(name, config, cwd));
-					writeDecisions.set(name, shouldWrite);
-				}
-				const packageDepsToInstall = {};
-				for (const [name, entry] of allComponents) if (writeDecisions.get(name)) Object.assign(packageDepsToInstall, entry.packageDeps);
-				const approvedComponents = Array.from(allComponents.entries()).filter(([name]) => writeDecisions.get(name));
-				const needsUtils = Array.from(approvedComponents).some(([, entry]) => entry.needsUtils === true);
-				const utilsPath = join(cwd, config.utilsFilePath);
-				const utilsFileExists = await fsExtra.pathExists(utilsPath);
-				await tasks([
-					...approvedComponents.map(([name, entry]) => ({
-						title: `Installing ${name}`,
-						task: async () => {
-							for (const registryFilePath of entry.files) {
-								const content = await fetchRegistryFileContent(registryFilePath);
-								await writeFileWithDirs(mapComponentsRegistryPathToProjectDest(registryFilePath, config, cwd), content);
-							}
-							return `${name} installed (${entry.files.length} file(s))`;
-						}
-					})),
-					{
-						title: "Installing packages",
-						task: async (message) => installMissingPackages(packageDepsToInstall, cwd, message)
-					},
-					...needsUtils && !utilsFileExists ? [{
-						title: "Writing utils file",
-						task: async () => {
-							await writeFileWithDirs(utilsPath, await fetchUtilsFileContent());
-							return `${config.utilsFilePath} written`;
-						}
-					}] : []
-				]);
-				const skippedNames = Array.from(writeDecisions.entries()).filter(([, shouldWrite]) => !shouldWrite).map(([name]) => name);
-				note([
-					`Installed  > ${approvedComponents.map(([name]) => name).join(", ") || "none"}`,
-					skippedNames.length > 0 ? `Skipped    > ${skippedNames.join(", ")}` : "",
-					"",
-					"Import components from your components directory to use them."
-				].filter(Boolean).join("\n"), "Component(s) added");
-				outro("All set!");
-			} catch (error) {
-				log.error(`Failed to add component(s): ${error}`);
-				process.exit(1);
-			}
-		}
-	});
-}
-//#endregion
 //#region src/commands/remove.ts
 /**
-* Command: `centoui remove <component>`
-*
 * Removes a single installed component and its files from the user's project.
-*
-* Flow:
-*  1. Confirm the component is actually installed.
-*  2. Fetch the registry and check whether any other installed components
-*     declare this one as a `componentDep` — block removal if so.
-*  3. Collect the packages still required by remaining components so we
-*     know which of this component's packages become orphaned.
-*  4. Ask for confirmation, then delete the component directory and remove
-*     any newly orphaned npm packages.
-*  5. Check if any utils file is no longer needed and remove it if so(with confirmation from the user).
+* @returns The Citty command definition that executes the 'remove' CLI process.
 */
 function remove() {
 	return defineCommand({
 		meta: {
-			name: "remove",
-			description: "Remove an installed component from your project"
+			description: "Remove an installed component from your project",
+			name: "remove"
 		},
 		args: { component: {
-			type: "positional",
+			description: "Name of the component to remove (e.g. \"button\")",
 			required: true,
-			description: "Name of the component to remove (e.g. \"button\")"
+			type: "positional"
 		} },
-		async run({ args }) {
-			try {
-				const cwd = process.cwd();
-				const componentName = args.component;
-				intro("CentoUI — Remove component");
-				const config = await loadCentoUIConfig(cwd);
-				if (!await checkIsComponentInstalled(componentName, config, cwd)) throw new Error(`Component "${componentName}" is not installed.`);
-				const componentInstallDir = resolveComponentInstallDir(componentName, config, cwd);
-				const registry = await fetchFullRegistry();
-				const targetEntry = registry.components.find((component) => component.name === componentName);
-				if (!targetEntry) throw new Error(`"${componentName}" was not found in the registry. Aborting to avoid a partial removal.`);
-				const remainingNames = (await listInstalledComponentNames(config, cwd)).filter((name) => name !== componentName);
-				const dependents = /* @__PURE__ */ new Set();
-				const packagesStillNeeded = {};
-				for (const name of remainingNames) {
-					const entry = registry.components.find((component) => component.name === name);
-					if (!entry) continue;
-					if (entry.componentDeps?.includes(componentName)) dependents.add(name);
-					Object.assign(packagesStillNeeded, entry.packageDeps || {});
-				}
-				if (dependents.size > 0) {
-					const list = Array.from(dependents).map((dependent) => `  · ${dependent}`).join("\n");
-					throw new Error(`Cannot remove "${componentName}" — the following installed components depend on it:\n${list}`);
-				}
-				const confirmed = await confirm({
-					message: `Remove "${componentName}"?`,
-					initialValue: false
-				});
-				if (isCancel(confirmed) || !confirmed) {
-					cancel("Removal cancelled.");
-					process.exit(0);
-				}
-				await tasks([{
-					title: `Removing ${componentName}`,
-					task: async () => {
-						await fsExtra.remove(componentInstallDir);
-						return `${componentName} removed`;
-					}
-				}, {
-					title: "Removing orphaned packages",
-					task: async (message) => removeOrphanedPackages(targetEntry.packageDeps || {}, packagesStillNeeded, cwd, message)
-				}]);
-				const removedPackages = Object.keys(targetEntry.packageDeps || {}).filter((pkg) => !(pkg in packagesStillNeeded));
-				if (removedPackages.length > 0) note(removedPackages.map((pkg) => `  · ${pkg}`).join("\n"), "Packages removed");
-				if (!remainingNames.some((name) => {
-					return registry.components.find((c) => c.name === name)?.needsUtils === true;
-				})) {
-					const utilsPath = join(cwd, config.utilsFilePath);
-					if (await fsExtra.pathExists(utilsPath)) {
-						const shouldDeleteUtils = await confirm({
-							message: "Delete utils file? (no components require it anymore)",
-							initialValue: false
-						});
-						if (!isCancel(shouldDeleteUtils) && shouldDeleteUtils) {
-							await fsExtra.remove(utilsPath);
-							note(`${config.utilsFilePath} deleted`, "Utils file removed");
-						}
-					}
-				}
-				outro("All set!");
-			} catch (error) {
-				log.error(`Failed to remove component: ${error}`);
-				process.exit(1);
+		run: async ({ args }) => {
+			const cwd = process.cwd();
+			const component = args.component;
+			intro("CentoUI — Remove components!");
+			log.step("Loading config.");
+			const config = await loadConfig$1(cwd);
+			log.step("Resolving workspace.");
+			const installedComponents = await getInstalledComponents(config, cwd);
+			if (!installedComponents.includes(component)) throw new Error(`${component} is not installed.`);
+			log.step("Fetching registry.");
+			const registry = await fetchRegistry();
+			log.step("Resolving components.");
+			const componentEntry = registry.components.find((entry) => entry.name === component);
+			if (!componentEntry) throw new Error(`${component} not found in registry.`);
+			const exceptToBeRemovedComponents = installedComponents.filter((entry) => entry !== component);
+			const componentDependents = /* @__PURE__ */ new Set();
+			const neededDependencies = /* @__PURE__ */ new Map();
+			for (const name of exceptToBeRemovedComponents) {
+				const entry = registry.components.find((entry) => entry.name === name);
+				if (entry?.componentDependencies?.includes(component)) componentDependents.add(name);
+				neededDependencies.set(name, entry?.npmDependencies || {});
 			}
+			if (componentDependents.size > 0) throw new Error(`Cannot remove ${component} these components depend on it: ${[...componentDependents].join(", ")}`);
+			const componentDir = join(cwd, config.componentsDir, component);
+			const dependenciesToUninstall = Object.keys(componentEntry?.npmDependencies || {}).filter((name) => !neededDependencies.has(name));
+			await tasks([{
+				task: async () => {
+					await fsExtra.remove(componentDir);
+					return `${component} removed!`;
+				},
+				title: `Removing ${component}.`
+			}, {
+				enabled: dependenciesToUninstall.length > 0,
+				task: async (message) => {
+					for (const name of dependenciesToUninstall) {
+						message(`Uninstalling ${name}.`);
+						await uninstallDependency(name, cwd);
+					}
+					return "Orphaned dependencies removed!";
+				},
+				title: `Removing orphaned dependencies`
+			}]);
+			outro(`${component} removed from your project!`);
 		}
 	});
 }
@@ -751,8 +466,8 @@ runMain(defineCommand({
 		version: VERSION
 	},
 	subCommands: {
-		init,
 		add,
+		init,
 		remove
 	}
 }));