centoui-cli 1.0.0-alpha.9 → 1.0.0

package/README.md

@@ -1,44 +1,116 @@
-# centoui-cli
+<div align="center">
+  <h1>centoui-cli</h1>
+  <p><strong>Manage CentoUI components from the terminal.</strong></p>
+  <p>
+    <a href="https://npmx.dev/package/centoui-cli"><img src="https://img.shields.io/npm/v/centoui-cli.svg?style=plastic&label=NPM%20Version&color=blue" alt="NPM Version"></a>
+    <a href="https://npmx.dev/package/centoui-cli"><img src="https://img.shields.io/npm/dw/centoui-cli.svg?style=plastic&label=NPM%20Downloads&color=blue" alt="NPM Downloads"></a>
+    <a href="https://npmx.dev/package/centoui-cli"><img src="https://img.shields.io/npm/unpacked-size/centoui-cli?style=plastic&label=NPM%20Unpacked%20Size&color=blue" alt="NPM Unpacked Size"></a>
+  </p>
+</div>
 
-[![npm version](https://img.shields.io/npm/v/centoui-cli.svg?style=flat-square)](https://www.npmjs.com/package/centoui-cli)
-[![npm downloads](https://img.shields.io/npm/dm/centoui-cli.svg?style=flat-square)](https://www.npmjs.com/package/centoui-cli)
-[![license](https://img.shields.io/github/license/favorodera/centoui.svg?style=flat-square)](https://github.com/favorodera/centoui/blob/main/LICENSE)
+<br>
 
-**CentoUI CLI: Manage your CentoUI components with ease.**
-
-`centoui-cli` is the official command-line interface for [CentoUI](https://github.com/favorodera/centoui). It allows you to initialize CentoUI in your project, add new components, and manage their versions directly from your terminal.
+`centoui-cli` is the command-line interface for [CentoUI](../core). It initializes projects, pulls component source files from the registry into your codebase, resolves dependency trees automatically, and cleans up when you remove components.
 
 ## Commands
 
-- **`init`**: Set up a new CentoUI project (generates `centoui.config.ts` and `centoui.css`).
-- **`add [component]`**: Add specific components to your project. Peer dependencies install automatically.
-- **`remove [component]`**: Cleanly remove components and their dependencies.
+### `centoui init`
 
-## Usage
+Scaffolds a new CentoUI project in your current directory.
 
 ```bash
-# Initialize CentoUI in your project
 pnpm dlx centoui init
+```
+
+**What it does:**
+
+1. Prompts you for a component directory (default: `src/components/centoui`), a utils file path (default: `src/utils/centoui-utils.ts`), and theme CSS path (default: `src/assets/css/centoui.css`).
+2. Writes `centoui.config.ts` with your chosen paths and default icon mappings.
+3. Fetches and writes the `centoui.css` theme file with all light/dark color tokens.
+4. Writes the `centoui-utils.ts` file with all utility functions.
+5. Creates the component directory.
+6. Installs global peer dependencies (`vue`, `reka-ui`, `tailwindcss`, etc.).
+
+---
+
+### `centoui add <component> [component...]`
+
+Adds one or more components to your project.
+
+```bash
+pnpm dlx centoui add button accordion select
+```
+
+**What it does:**
+
+1. Fetches the component registry from GitHub.
+2. Resolves the full dependency tree — if `select` depends on `popover`, both are installed.
+3. Asks before overwriting any component that already exists.
+4. Downloads `.vue` and `index.ts` files for each component into your configured directory.
+5. Installs any npm packages required by the added components.
 
-# Add components
-pnpm dlx centoui add button dialog input select
+---
+
+### `centoui remove <component>`
+
+Removes an installed component and cleans up orphaned packages.
+
+```bash
+pnpm dlx centoui remove accordion
 ```
 
+**What it does:**
+
+1. Checks that the component is actually installed.
+2. Blocks removal if other installed components depend on it (e.g., you can't remove `popover` while `select` is installed).
+3. Deletes the component's directory.
+4. Uninstalls npm packages that are no longer needed by any remaining component.
+
+## Version-Locked Asset Fetching
+
+Every network request the CLI makes — the registry index, individual component files, the theme CSS, and the default config — is resolved against the **exact git tag that matches the installed version of `centoui-cli`**.
+
+The base URL for all assets is derived directly from the CLI's own `package.json` version at build time:
+
+```
+https://raw.githubusercontent.com/favorodera/centoui/refs/tags/v<VERSION>/packages/core/src
+```
+
+This means:
+
+- If you have `centoui-cli@1.2.3` installed, all fetched assets come from the `v1.2.3` tag of the `centoui` repository — never from `main` or any other release.
+- The registry, component source files, CSS theme, and config defaults are always in sync with each other and with the CLI you are running.
+- Upgrading the CLI upgrades the version tag automatically — no separate step needed.
+
+This design eliminates an entire class of version mismatch bugs where the CLI and the component source could drift out of sync.
+
 ## Configuration
 
-The CLI generates a `centoui.config.ts` file in your root directory. You can customize the component directory, theme directory, and utility directory here.
+After running `centoui init`, your project root will contain a `centoui.config.ts`:
 
 ```ts
-import { defineConfig } from "centoui"
+import { defineConfig } from 'centoui'
 
 export default defineConfig({
-  version: "1.0.0",
-  componentsDir: "./src/components/centoui",
-  themeFilePath: "./src/assets/css/centoui.css",
+  componentsDir: './src/components/centoui',
   icons: {
-    check: "lucide:check",
-    close: "lucide:x",
-    menu: "lucide:menu",
+    check: 'lucide:check',
+    chevronDoubleLeft: 'lucide:chevrons-left',
+    chevronDoubleRight: 'lucide:chevrons-right',
+    chevronDown: 'lucide:chevron-down',
+    chevronLeft: 'lucide:chevron-left',
+    chevronRight: 'lucide:chevron-right',
+    chevronUp: 'lucide:chevron-up',
+    close: 'lucide:x',
+    ellipsis: 'lucide:ellipsis',
   },
+  themeFilePath: './src/assets/css/centoui.css',
+  utilsFilePath: './src/utils/centoui-utils.ts',
 })
-```
+```
+
+The `icons` map lets you swap icon libraries without touching component code. Components reference icons by their slot name (e.g., `check`, `close`), and the config resolves them to [Iconify](https://iconify.design/) IDs.
+
+## License
+
+[MIT](../../LICENSE) &copy; [Favour Emeka](https://github.com/favorodera)

package/dist/index.d.mts

@@ -1,63 +1,35 @@
 //#region src/types.d.ts
-/**
- * Mirrors the `globals.json` registry schema.
- * Defines properties that every CentoUI project must have.
- */
-type GlobalsRegistry = {
-  /**
-   * NPM packages that are required in every CentoUI project.
-   * Keys are package names; values are semver version ranges (e.g. `"^4.2.2"`).
-   */
-  packageDeps: Record<string, string>;
-};
-/**
- * Mirrors the `component.json` registry schema.
- * Describes a single installable CentoUI component.
- */
-type ComponentRegistry = {
-  /** Unique identifier for the component. Matches its registry filename (e.g. `"button"`). */name: string; /** Short human-readable description shown in CLI output. */
-  description?: string;
-  /**
-   * Source file paths relative to `packages/core/src/`.
-   * All paths start with `components/` by convention (e.g. `"components/button/button.vue"`).
-   * The CLI fetches each file from GitHub and writes it into the user's components directory.
-   */
-  files: string[];
-  /**
-   * Names of other CentoUI components that must be installed alongside this one.
-   * The CLI resolves the full dependency tree automatically.
-   */
-  componentDeps: string[];
-  /**
-   * NPM packages required specifically by this component,
-   * in addition to the global dependencies defined in `GlobalsRegistry`.
-   * Keys are package names; values are semver version ranges.
-   */
-  packageDeps: Record<string, string>;
-};
-/**
- * The complete CentoUI registry — the `index.json` file fetched from GitHub.
- * Contains global project dependencies and the full list of installable components.
- */
-type Registry = {
-  /** Global properties that every CentoUI project must have. */globals: GlobalsRegistry; /** All components that can be installed with `centoui add`. */
-  components: ComponentRegistry[];
-};
-/**
- * The user-side CentoUI configuration, stored in `centoui.config.ts`.
- * Generated by `centoui init` and consumed by every subsequent CLI command.
- */
-type CentoUIConfig = {
-  /** The CentoUI version this project was initialised with. */version: string; /** Relative path (from project root) to the directory where components are installed. */
-  componentsDir: string; /** Relative path (from project root) to the CSS file that receives theme and component styles. */
+/** Describes a single installable CentoUI component. */
+interface ComponentRegistryEntry {
+  /** Unique identifier for the component (e.g. `"button"`). */
+  name: string;
+  /** Source file paths relative to `packages/core/src/`. */
+  files: Array<string>;
+  /** Names of other CentoUI components required by this one. */
+  componentDependencies?: Array<string>;
+  /** NPM packages required by this component. */
+  npmDependencies?: Record<string, string>;
+}
+/** The complete CentoUI registry (`index.json`). */
+interface Registry {
+  /** NPM packages required in every CentoUI project. */
+  npmDependencies: Record<string, string>;
+  /** Installable components. */
+  components: Array<ComponentRegistryEntry>;
+}
+/** User configuration stored in `centoui.config.ts`. */
+interface CentoUIConfig {
+  /** Relative path to the component installation directory. */
+  componentsDir: string;
+  /** Relative path to the CSS file. */
   themeFilePath: string;
-  /**
-   * Maps internal CentoUI icon slot names to Iconify icon IDs.
-   * Components reference icon slots by their internal name so you can swap icon libraries freely.
-   *
-   * @example { menu: 'lucide:menu', close: 'lucide:x' }
-   */
+  /** Maps internal icon slot names to Iconify IDs. */
   icons: Record<string, string>;
-};
+}
+/** Partial package.json structure needed by the CLI. */
+interface PackageJson {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}
 //#endregion
-export { CentoUIConfig, ComponentRegistry, GlobalsRegistry, Registry };
+export { CentoUIConfig, ComponentRegistryEntry, PackageJson, Registry };

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 { pathToFileURL } from "node:url";
 //#endregion
 //#region src/constants.ts
 /** CentoUI current package version, sourced directly from package.json. */
-const VERSION = "1.0.0-alpha.9";
+const VERSION = "1.0.0";
 /** File name for the user-side CentoUI config (created by `centoui init`). */
 const CONFIG_FILE_NAME = "centoui.config.ts";
 /**
@@ -18,14 +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}/css/centoui.css`;
+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.
@@ -35,593 +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, version]) => alreadyInstalled[name] !== version).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 file path into the absolute destination path
-* inside the user's project.
-*
-* Registry 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 registryFilePath - 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'
-* mapRegistryPathToProjectDest('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 mapRegistryPathToProjectDest(registryFilePath, config, cwd) {
-	const pathWithoutRegistryPrefix = registryFilePath.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?` });
+	const answer = await confirm({
+		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`.
-*
-* Uses a dynamic `import()` via a `file://` URL so that TypeScript config files
-* compiled by the user's build tooling are resolved correctly at runtime.
-*
-* @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 configFilePath = join(cwd, CONFIG_FILE_NAME);
+async function installDependency(name, version, cwd) {
 	try {
-		if (!await fsExtra.pathExists(configFilePath)) throw new Error(`[loadCentoUIConfig] "${CONFIG_FILE_NAME}" not found in "${cwd}". Run \`centoui init\` first.`);
-		return (await import(pathToFileURL(configFilePath).href)).default;
+		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(`[loadCentoUIConfig] Failed to import "${configFilePath}": ${error}`);
+		throw new Error(`Failed to install ${name}`, { cause: error });
 	}
 }
 /**
-* 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.
+* Uninstalls a dependency using nypm.
+* @param name Dependency name.
+* @param cwd Current working directory.
+* @returns Status message.
 */
-function buildDefaultConfigFileContent(themeFilePath, componentsDir) {
-	return `import { defineConfig } from 'centoui'
-
-export default defineConfig({
-  version: '${VERSION}',
-  componentsDir: '${componentsDir}',
-  themeFilePath: '${themeFilePath}',
-  icons: {
-    check: 'lucide:check',
-    close: 'lucide:x',
-    menu: 'lucide:menu',
-  },
-})
-`;
+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.
+* 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 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();
+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 and theme CSS file path.
-*  2. Ask upfront whether to overwrite any of the three output paths
-*     (config file, theme CSS, components directory) 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
-					})
-				}, { 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: `Writing ${CONFIG_FILE_NAME}`,
-						task: async () => {
-							if (!shouldWriteConfig) return `Skipped — "${CONFIG_FILE_NAME}" already exists`;
-							await fsExtra.outputFile(configPath, buildDefaultConfigFileContent(directories.themeFilePath, directories.componentDir), "utf-8");
-							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`;
-							const themeContent = await fetchThemeCSSContent();
-							await fsExtra.outputFile(themePath, themeContent, "utf-8");
-							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. 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));
-				await tasks([...approvedComponents.map(([name, entry]) => ({
-					title: `Installing ${name}`,
-					task: async () => {
-						for (const registryFilePath of entry.files) {
-							const content = await fetchRegistryFileContent(registryFilePath);
-							await writeFileWithDirs(mapRegistryPathToProjectDest(registryFilePath, config, cwd), content);
-						}
-						return `${name} installed (${entry.files.length} file(s))`;
-					}
-				})), {
-					title: "Installing packages",
-					task: async (message) => installMissingPackages(packageDepsToInstall, cwd, message)
-				}]);
-				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.
+* @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}"?` });
-				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");
-				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!`);
 		}
 	});
 }
@@ -633,8 +466,8 @@ runMain(defineCommand({
 		version: VERSION
 	},
 	subCommands: {
-		init,
 		add,
+		init,
 		remove
 	}
 }));

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "centoui-cli",
   "type": "module",
-  "version": "1.0.0-alpha.9",
+  "version": "1.0.0",
   "private": false,
   "description": "Official CLI for CentoUI.",
   "author": "Favour Emeka <favorodera@gmail.com>",
   "license": "MIT",
+  "funding": "https://github.com/sponsors/favorodera",
   "homepage": "https://centoui.vercel.app",
   "repository": {
     "type": "git",
@@ -14,6 +15,13 @@
   "bugs": {
     "url": "https://github.com/favorodera/centoui/issues"
   },
+  "keywords": [
+    "cli",
+    "vue",
+    "ui",
+    "components",
+    "tailwindcss"
+  ],
   "publishConfig": {
     "access": "public"
   },
@@ -22,33 +30,34 @@
     "./package.json": "./package.json"
   },
   "types": "./dist/types.d.mts",
-  "files": [
-    "dist"
-  ],
   "bin": {
     "centoui": "./dist/index.mjs"
   },
-  "devDependencies": {
-    "@types/fs-extra": "^11.0.4",
-    "tsdown": "^0.21.7",
-    "type-fest": "^5.6.0",
-    "@vitest/ui": "^4.1.5",
-    "vitest": "^4.1.2"
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.0.0",
+    "pnpm": ">=11.0.0"
   },
   "dependencies": {
-    "@clack/prompts": "^1.2.0",
+    "@clack/prompts": "^1.5.1",
+    "c12": "^4.0.0-beta.5",
     "citty": "^0.2.2",
-    "fs-extra": "^11.3.4",
-    "nypm": "^0.6.6",
+    "fs-extra": "^11.3.5",
+    "nypm": "^0.6.7",
     "pathe": "^2.0.3"
   },
-  "engines": {
-    "node": ">=22.0.0"
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@vitest/ui": "^4.1.8",
+    "tsdown": "^0.22.2",
+    "vitest": "^4.1.8"
   },
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
-    "test": "vitest",
+    "test": "vitest run",
     "test:watch": "vitest watch --ui",
     "typecheck": "tsc --noEmit",
     "lint": "eslint . --fix"