@docyrus/cli 0.3.1 → 0.5.0

package/dist/cli.js

@@ -1,25 +1,475 @@
 #!/usr/bin/env node
+import { join, resolve, dirname } from 'path';
+import { URL as URL$1, fileURLToPath } from 'url';
 import { Command } from 'commander';
 import { RestApiClient, AuthenticationError as AuthenticationError$1 } from '@docyrus/api-client';
 import { createServer } from 'http';
-import { URL, fileURLToPath } from 'url';
 import { randomBytes, createDecipheriv, createCipheriv, scryptSync, createHash } from 'crypto';
 import open from 'open';
-import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync, constants as constants$1 } from 'fs';
-import { join, resolve, dirname } from 'path';
+import { existsSync, readFileSync, readdirSync, mkdirSync, writeFileSync, unlinkSync, constants as constants$1 } from 'fs';
 import { homedir, arch, release, platform, hostname, userInfo } from 'os';
 import Conf from 'conf';
 import chalk4 from 'chalk';
-import ora from 'ora';
-import { select, input, password, confirm } from '@inquirer/prompts';
-import { exec } from 'child_process';
+import ora2 from 'ora';
+import { select, input, password, confirm, checkbox } from '@inquirer/prompts';
+import { exec, execFileSync } from 'child_process';
 import { promisify } from 'util';
-import { access, constants, writeFile, readFile, mkdir, cp, rm, readdir } from 'fs/promises';
+import { access, constants, writeFile, readFile, mkdir, chmod, cp, rm, readdir } from 'fs/promises';
 import { downloadTemplate } from 'giget';
 import { generateFromOpenAPI } from '@docyrus/tanstack-db-generator';
 
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  mod
+));
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js"() {
+  }
+});
+
+// ../../node_modules/.pnpm/dotenv@17.3.1/node_modules/dotenv/package.json
+var require_package = __commonJS({
+  "../../node_modules/.pnpm/dotenv@17.3.1/node_modules/dotenv/package.json"(exports$1, module) {
+    module.exports = {
+      name: "dotenv",
+      version: "17.3.1",
+      description: "Loads environment variables from .env file",
+      main: "lib/main.js",
+      types: "lib/main.d.ts",
+      exports: {
+        ".": {
+          types: "./lib/main.d.ts",
+          require: "./lib/main.js",
+          default: "./lib/main.js"
+        },
+        "./config": "./config.js",
+        "./config.js": "./config.js",
+        "./lib/env-options": "./lib/env-options.js",
+        "./lib/env-options.js": "./lib/env-options.js",
+        "./lib/cli-options": "./lib/cli-options.js",
+        "./lib/cli-options.js": "./lib/cli-options.js",
+        "./package.json": "./package.json"
+      },
+      scripts: {
+        "dts-check": "tsc --project tests/types/tsconfig.json",
+        lint: "standard",
+        pretest: "npm run lint && npm run dts-check",
+        test: "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
+        "test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+        prerelease: "npm test",
+        release: "standard-version"
+      },
+      repository: {
+        type: "git",
+        url: "git://github.com/motdotla/dotenv.git"
+      },
+      homepage: "https://github.com/motdotla/dotenv#readme",
+      funding: "https://dotenvx.com",
+      keywords: [
+        "dotenv",
+        "env",
+        ".env",
+        "environment",
+        "variables",
+        "config",
+        "settings"
+      ],
+      readmeFilename: "README.md",
+      license: "BSD-2-Clause",
+      devDependencies: {
+        "@types/node": "^18.11.3",
+        decache: "^4.6.2",
+        sinon: "^14.0.1",
+        standard: "^17.0.0",
+        "standard-version": "^9.5.0",
+        tap: "^19.2.0",
+        typescript: "^4.8.4"
+      },
+      engines: {
+        node: ">=12"
+      },
+      browser: {
+        fs: false
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/dotenv@17.3.1/node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "../../node_modules/.pnpm/dotenv@17.3.1/node_modules/dotenv/lib/main.js"(exports$1, module) {
+    init_esm_shims();
+    var fs = __require("fs");
+    var path2 = __require("path");
+    var os = __require("os");
+    var crypto2 = __require("crypto");
+    var packageJson = require_package();
+    var version = packageJson.version;
+    var TIPS = [
+      "\u{1F510} encrypt with Dotenvx: https://dotenvx.com",
+      "\u{1F510} prevent committing .env to code: https://dotenvx.com/precommit",
+      "\u{1F510} prevent building .env in docker: https://dotenvx.com/prebuild",
+      "\u{1F916} agentic secret storage: https://dotenvx.com/as2",
+      "\u26A1\uFE0F secrets for agents: https://dotenvx.com/as2",
+      "\u{1F6E1}\uFE0F auth for agents: https://vestauth.com",
+      "\u{1F6E0}\uFE0F  run anywhere with `dotenvx run -- yourcommand`",
+      "\u2699\uFE0F  specify custom .env file path with { path: '/custom/path/.env' }",
+      "\u2699\uFE0F  enable debug logging with { debug: true }",
+      "\u2699\uFE0F  override existing env vars with { override: true }",
+      "\u2699\uFE0F  suppress all logs with { quiet: true }",
+      "\u2699\uFE0F  write to custom object with { processEnv: myObject }",
+      "\u2699\uFE0F  load multiple .env files with { path: ['.env.local', '.env'] }"
+    ];
+    function _getRandomTip() {
+      return TIPS[Math.floor(Math.random() * TIPS.length)];
+    }
+    function parseBoolean(value) {
+      if (typeof value === "string") {
+        return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
+      }
+      return Boolean(value);
+    }
+    function supportsAnsi() {
+      return process.stdout.isTTY;
+    }
+    function dim(text) {
+      return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
+    }
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options) {
+      options = options || {};
+      const vaultPath = _vaultPath(options);
+      options.path = vaultPath;
+      const result = DotenvModule.configDotenv(options);
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _warn(message) {
+      console.error(`[dotenv@${version}][WARN] ${message}`);
+    }
+    function _debug(message) {
+      console.log(`[dotenv@${version}][DEBUG] ${message}`);
+    }
+    function _log(message) {
+      console.log(`[dotenv@${version}] ${message}`);
+    }
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path2.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path2.join(os.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options) {
+      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (debug || !quiet) {
+        _log("Loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    function configDotenv(options) {
+      const dotenvPath = path2.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("No encoding is specified. UTF-8 is used by default");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path3 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs.readFileSync(path3, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`Failed to load ${path3} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      const populated = DotenvModule.populate(processEnv, parsedAll, options);
+      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+      if (debug || !quiet) {
+        const keysCount = Object.keys(populated).length;
+        const shortPaths = [];
+        for (const filePath of optionPaths) {
+          try {
+            const relative = path2.relative(process.cwd(), filePath);
+            shortPaths.push(relative);
+          } catch (e) {
+            if (debug) {
+              _debug(`Failed to load ${filePath} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        _log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+      }
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    function decrypt2(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto2.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      const populated = {};
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+            populated[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
+        }
+      }
+      return populated;
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config,
+      decrypt: decrypt2,
+      parse,
+      populate
+    };
+    module.exports.configDotenv = DotenvModule.configDotenv;
+    module.exports._configVault = DotenvModule._configVault;
+    module.exports._parseVault = DotenvModule._parseVault;
+    module.exports.config = DotenvModule.config;
+    module.exports.decrypt = DotenvModule.decrypt;
+    module.exports.parse = DotenvModule.parse;
+    module.exports.populate = DotenvModule.populate;
+    module.exports = DotenvModule;
+  }
+});
+
+// src/cli.ts
+init_esm_shims();
+
+// src/commands/index.ts
+init_esm_shims();
+
+// src/commands/login.ts
+init_esm_shims();
+
+// src/auth/index.ts
+init_esm_shims();
+
+// src/auth/credential-auth.ts
+init_esm_shims();
+
 // src/config/constants.ts
-var DOCYRUS_API_URL = "https://api.docyrus.com";
+init_esm_shims();
+var DOCYRUS_API_URL = "https://alpha-api.docyrus.com";
 var OAUTH_CLIENT_ID = "90565525-8283-4881-82a9-8613eb82ae27";
 var OAUTH_SCOPES = "offline_access Read.All Users.Read Users.Read.All DS.Read.All".split(" ");
 var OAUTH_CALLBACK_PORT_MIN = 9876;
@@ -36,11 +486,13 @@ var TOKEN_KEYS = {
   GITHUB_TOKEN: "githubToken"
   // For private template access - persists after logout
 };
+var REGISTRY_BASE_URL = "https://ui.docy.app/r";
 var CLI_NAME = "docyrus";
 var CLI_VERSION = "0.0.1";
 var NPM_PACKAGE_NAME = "docyrus";
 
 // src/utils/errors.ts
+init_esm_shims();
 var CliError = class extends Error {
   exitCode;
   suggestion;
@@ -107,6 +559,36 @@ var ConflictingFlagsError = class extends CliError {
     this.name = "ConflictingFlagsError";
   }
 };
+var ComponentNotFoundError = class extends CliError {
+  constructor(name) {
+    super(
+      `"${name}" not found in the registry.`,
+      1,
+      "Check the name and try again. Run `docyrus add --help` for usage."
+    );
+    this.name = "ComponentNotFoundError";
+  }
+};
+var PremiumAuthError = class extends CliError {
+  constructor(name) {
+    super(
+      `"${name}" is a premium component. Authentication required.`,
+      1,
+      "Run `docyrus login` to authenticate, then try again."
+    );
+    this.name = "PremiumAuthError";
+  }
+};
+var MissingConfigError = class extends CliError {
+  constructor() {
+    super(
+      "components.json not found.",
+      1,
+      "Run `npx shadcn@latest init` first to initialize your project."
+    );
+    this.name = "MissingConfigError";
+  }
+};
 
 // src/auth/credential-auth.ts
 function getApiClient() {
@@ -195,6 +677,12 @@ async function refreshAccessToken(refreshToken) {
     throw new AuthenticationError("Session expired. Please log in again.");
   }
 }
+
+// src/auth/oauth-auth.ts
+init_esm_shims();
+
+// src/auth/oauth-server.ts
+init_esm_shims();
 var SUCCESS_HTML = `
 <!DOCTYPE html>
 <html>
@@ -377,7 +865,7 @@ async function startCallbackServer(expectedState) {
     rejectResult(new TimeoutError("OAuth authentication timed out."));
   }, OAUTH_TIMEOUT_MS);
   const server = createServer((req, res) => {
-    const url = new URL(req.url || "/", `http://127.0.0.1:${port}`);
+    const url = new URL$1(req.url || "/", `http://127.0.0.1:${port}`);
     if (url.pathname === "/callback") {
       const code = url.searchParams.get("code");
       const state2 = url.searchParams.get("state");
@@ -421,6 +909,9 @@ async function startCallbackServer(expectedState) {
     cleanup
   };
 }
+
+// src/utils/browser.ts
+init_esm_shims();
 async function openBrowser(url) {
   await open(url);
 }
@@ -505,12 +996,24 @@ async function loginWithOAuth(options = {}) {
     cleanup();
   }
 }
+
+// src/storage/index.ts
+init_esm_shims();
+
+// src/storage/file-storage.ts
+init_esm_shims();
+
+// src/utils/platform.ts
+init_esm_shims();
 function getHomeDir() {
   return homedir();
 }
 function getConfigDir() {
   return join(getHomeDir(), CONFIG_DIR);
 }
+
+// src/storage/encryption.ts
+init_esm_shims();
 var ALGORITHM = "aes-256-gcm";
 var KEY_LENGTH = 32;
 var IV_LENGTH = 16;
@@ -626,6 +1129,7 @@ var FileStorage = class {
 };
 
 // src/storage/keychain-storage.ts
+init_esm_shims();
 var keytar = null;
 async function getKeytar() {
   if (keytar !== null) {
@@ -696,6 +1200,7 @@ var KeychainStorage = class {
 };
 
 // src/storage/cli-token-manager.ts
+init_esm_shims();
 var CliTokenManager = class {
   keychain;
   fileStorage;
@@ -795,8 +1300,15 @@ function getTokenManager() {
   }
   return instance;
 }
+
+// src/config/index.ts
+init_esm_shims();
+
+// src/config/config-manager.ts
+init_esm_shims();
 var defaults = {
-  telemetryEnabled: true
+  telemetryEnabled: true,
+  helpTheme: "default"
 };
 var ConfigManager = class {
   config;
@@ -826,6 +1338,12 @@ var ConfigManager = class {
   }
 };
 var configManager = new ConfigManager();
+
+// src/ui/index.ts
+init_esm_shims();
+
+// src/ui/logger.ts
+init_esm_shims();
 var logger = {
   success(message) {
     console.info(chalk4.green("\u2713"), message);
@@ -860,6 +1378,9 @@ var logger = {
     return chalk4.cyan.underline(url);
   }
 };
+
+// src/ui/output.ts
+init_esm_shims();
 var state = {
   format: "text",
   data: {}
@@ -944,6 +1465,7 @@ var output = {
 };
 
 // src/ui/messages.ts
+init_esm_shims();
 var MESSAGES = {
   // Login
   LOGIN_SUCCESS: (email) => `Successfully logged in as ${email}`,
@@ -990,7 +1512,7 @@ var MESSAGES = {
   CREATE_SUCCESS: "Project created successfully!",
   CREATE_DOWNLOAD_OPENAPI: "Download OpenAPI spec for code generation?",
   CREATE_DOWNLOADING_OPENAPI: "Downloading OpenAPI specification...",
-  CREATE_OPENAPI_SUCCESS: (path) => `OpenAPI spec saved to ${path}`,
+  CREATE_OPENAPI_SUCCESS: (path2) => `OpenAPI spec saved to ${path2}`,
   // TanStack DB Generator
   TANSTACK_GENERATOR_PROMPT: "Generate TanStack Query collections from OpenAPI spec?",
   TANSTACK_GENERATOR_RUNNING: "Generating TanStack Query collections...",
@@ -1012,10 +1534,58 @@ var MESSAGES = {
   DOCYRUS_TOKEN_REQUIRED: "Docyrus token required for template download",
   DOCYRUS_TOKEN_PROMPT: "Enter Docyrus token:",
   DOCYRUS_TOKEN_SAVED: "Docyrus token saved successfully",
-  DOCYRUS_TOKEN_INVALID: "Invalid Docyrus token. Please check and try again."
+  DOCYRUS_TOKEN_INVALID: "Invalid Docyrus token. Please check and try again.",
+  // Add command
+  ADD_RESOLVING: "Resolving components and dependencies...",
+  ADD_INSTALLING_ITEM: (name) => `Installing ${name}...`,
+  ADD_INSTALLING_DEPS: (count) => `Installing ${count} dependenc${count === 1 ? "y" : "ies"}...`,
+  ADD_SUCCESS: (items, files) => `Done! Added ${items} item(s), ${files} file(s).`,
+  ADD_NO_ITEMS: "Please specify at least one item to add.",
+  ADD_NOT_FOUND: (name) => `"${name}" not found in the registry.`,
+  ADD_PREMIUM_AUTH: (name) => `"${name}" is a premium component. Authentication required.`,
+  ADD_FILE_EXISTS: (path2) => `File ${path2} already exists. Overwrite?`,
+  ADD_FILE_SKIPPED: (path2) => `Skipped: ${path2}`,
+  ADD_DRY_RUN_HEADER: "Dry run \u2014 the following changes would be made:",
+  ADD_MISSING_CONFIG: "components.json not found.",
+  ADD_MISSING_CONFIG_HINT: "Run `npx shadcn@latest init` first to initialize your project.",
+  ADD_DETECTED_STYLE: (style) => `Detected style: ${style}`,
+  ADD_DEPRECATED_BASE_STYLE: 'Your components.json uses a deprecated "base-*" style. The radix/base variant distinction has been removed. All components now use the unified registry (@docyrus/ui-*).',
+  // List command
+  LIST_HEADER: "Available Docyrus UI registry items:",
+  LIST_FETCHING: "Fetching registry index...",
+  LIST_FETCHING_NPM: "Fetching @docyrus npm packages...",
+  LIST_NPM_SUCCESS: "Fetched npm packages",
+  LIST_INSTALL_HINT: "Install with: docyrus add <name>",
+  LIST_NPM_HEADER: "Published @docyrus npm packages:",
+  LIST_NPM_LINK: "https://www.npmjs.com/settings/docyrus/packages",
+  // Commitlint command
+  COMMITLINT_DESCRIPTION: "Set up commitlint, husky, and lint-staged in your project",
+  COMMITLINT_NO_PROJECT: "Could not find a package.json.",
+  COMMITLINT_NO_PROJECT_HINT: "Run this command from within a JavaScript/TypeScript project.",
+  COMMITLINT_IS_MONOREPO: "Is this a monorepo?",
+  COMMITLINT_DETECTED_WORKSPACES: (count) => `Detected ${count} workspace(s)`,
+  COMMITLINT_NO_WORKSPACES: "No workspaces detected. Enter scopes manually.",
+  COMMITLINT_SCOPE_STRATEGY: "How should scopes be used?",
+  COMMITLINT_SELECT_SCOPES: "Select scopes to include:",
+  COMMITLINT_ADDITIONAL_SCOPES: "Enter additional scopes (comma-separated, or leave empty):",
+  COMMITLINT_CONFIRM_SCOPES: (scopes) => `Scopes: ${scopes.join(", ")}`,
+  COMMITLINT_CONFIG_EXISTS: "commitlint.config.ts already exists. Overwrite?",
+  COMMITLINT_HUSKY_EXISTS: ".husky/ directory already exists. Overwrite hooks?",
+  COMMITLINT_STEP_CONFIG: "Creating commitlint.config.ts",
+  COMMITLINT_STEP_HUSKY: "Setting up Husky hooks",
+  COMMITLINT_STEP_SCRIPT: "Creating commit-linter.sh script",
+  COMMITLINT_STEP_PACKAGE_JSON: "Updating package.json",
+  COMMITLINT_STEP_INSTALL: "Installing dependencies",
+  COMMITLINT_STEP_INIT_HUSKY: "Initializing Husky",
+  COMMITLINT_SUCCESS: "Commitlint setup complete!",
+  COMMITLINT_SUCCESS_HINT: "Your commits will now be validated against Conventional Commits format.",
+  COMMITLINT_DETECTED_PM: (pm) => `Package manager: ${pm}`
 };
+
+// src/ui/spinner.ts
+init_esm_shims();
 function createSpinner(text) {
-  return ora({
+  return ora2({
     text,
     spinner: "dots"
   });
@@ -1042,6 +1612,9 @@ async function withSpinner(text, fn, options) {
     throw error;
   }
 }
+
+// src/ui/prompts.ts
+init_esm_shims();
 async function promptEmail(defaultValue) {
   return input({
     message: MESSAGES.LOGIN_PROMPT_EMAIL,
@@ -1066,12 +1639,80 @@ async function promptPassword() {
     }
   });
 }
-({
+
+// src/ui/progress.ts
+init_esm_shims();
+var SYMBOLS = {
   pending: chalk4.dim("\u25CB"),
   in_progress: chalk4.cyan("\u25D0"),
   completed: chalk4.green("\u2713"),
   failed: chalk4.red("\u2717")
-});
+};
+function createMultiStepProgress(title, stepLabels) {
+  const steps = stepLabels.map((label) => ({
+    label,
+    status: "pending"
+  }));
+  let spinner = null;
+  let currentStep = -1;
+  const render = () => {
+    console.log();
+    console.log(chalk4.bold(title));
+    console.log();
+    for (const step of steps) {
+      const symbol = SYMBOLS[step.status];
+      const text = step.status === "in_progress" ? chalk4.cyan(step.label) : step.status === "completed" ? chalk4.green(step.label) : step.status === "failed" ? chalk4.red(step.label) : chalk4.dim(step.label);
+      console.log(`  ${symbol} ${text}`);
+      if (step.status === "failed" && step.error) {
+        console.log(`    ${chalk4.red(step.error)}`);
+      }
+    }
+    console.log();
+  };
+  return {
+    start(stepIndex) {
+      if (stepIndex < 0 || stepIndex >= steps.length) return;
+      if (spinner) {
+        spinner.stop();
+      }
+      currentStep = stepIndex;
+      steps[stepIndex].status = "in_progress";
+      spinner = ora2({
+        text: steps[stepIndex].label,
+        color: "cyan"
+      }).start();
+    },
+    complete(stepIndex) {
+      if (stepIndex < 0 || stepIndex >= steps.length) return;
+      if (spinner && currentStep === stepIndex) {
+        spinner.succeed(chalk4.green(steps[stepIndex].label));
+        spinner = null;
+      }
+      steps[stepIndex].status = "completed";
+    },
+    fail(stepIndex, error) {
+      if (stepIndex < 0 || stepIndex >= steps.length) return;
+      if (spinner && currentStep === stepIndex) {
+        spinner.fail(chalk4.red(steps[stepIndex].label));
+        spinner = null;
+      }
+      steps[stepIndex].status = "failed";
+      steps[stepIndex].error = error;
+    },
+    update(stepIndex, message) {
+      if (spinner && currentStep === stepIndex) {
+        spinner.text = message;
+      }
+    },
+    finish() {
+      if (spinner) {
+        spinner.stop();
+        spinner = null;
+      }
+      render();
+    }
+  };
+}
 function createSimpleProgress() {
   let spinner = null;
   return (step, current, total) => {
@@ -1080,7 +1721,7 @@ function createSimpleProgress() {
       spinner = null;
     }
     const text = current && total ? `${step} (${current}/${total})` : step;
-    spinner = ora({
+    spinner = ora2({
       text,
       color: "cyan"
     }).start();
@@ -1091,6 +1732,71 @@ function createSimpleProgress() {
   };
 }
 
+// src/ui/help.ts
+init_esm_shims();
+var palettes = {
+  default: {
+    title: (str) => chalk4.bold.cyan(str),
+    usage: (str) => chalk4.yellow(str),
+    command: (str) => chalk4.green(str),
+    argument: (str) => chalk4.magenta(str),
+    description: (str) => chalk4.dim(str)
+  },
+  monochrome: {
+    title: (str) => chalk4.bold(str),
+    usage: (str) => chalk4.bold(str),
+    command: (str) => chalk4.white(str),
+    argument: (str) => chalk4.underline(str),
+    description: (str) => chalk4.dim(str)
+  },
+  warm: {
+    title: (str) => chalk4.bold.yellow(str),
+    usage: (str) => chalk4.bold.red(str),
+    command: (str) => chalk4.yellow(str),
+    argument: (str) => chalk4.red(str),
+    description: (str) => chalk4.dim(str)
+  },
+  cool: {
+    title: (str) => chalk4.bold.blue(str),
+    usage: (str) => chalk4.cyan(str),
+    command: (str) => chalk4.blue(str),
+    argument: (str) => chalk4.cyan(str),
+    description: (str) => chalk4.dim(str)
+  },
+  neon: {
+    title: (str) => chalk4.bold.magenta(str),
+    usage: (str) => chalk4.cyan(str),
+    command: (str) => chalk4.green(str),
+    argument: (str) => chalk4.yellow(str),
+    description: (str) => chalk4.dim(str)
+  }
+};
+var HELP_THEMES = [
+  "default",
+  "monochrome",
+  "warm",
+  "cool",
+  "neon"
+];
+function previewTheme(theme) {
+  const p = palettes[theme];
+  return `${p.title("Commands:")} ${p.command("add")} ${p.argument("<name>")} ${p.description("description")}`;
+}
+function getHelpConfig(theme = "default") {
+  const p = palettes[theme];
+  return {
+    sortSubcommands: true,
+    sortOptions: true,
+    styleTitle: p.title,
+    styleUsage: p.usage,
+    styleCommandText: p.command,
+    styleOptionText: p.command,
+    styleArgumentText: p.argument,
+    styleSubcommandText: p.command,
+    styleDescriptionText: p.description
+  };
+}
+
 // src/commands/login.ts
 async function handleCredentialLogin(email) {
   const lastEmail = configManager.get("lastLoginEmail");
@@ -1170,6 +1876,7 @@ function registerLoginCommand(program2) {
 }
 
 // src/commands/logout.ts
+init_esm_shims();
 function registerLogoutCommand(program2) {
   program2.command("logout").description("Log out from Docyrus").action(async () => {
     const tokenManager = getTokenManager();
@@ -1192,7 +1899,11 @@ function registerLogoutCommand(program2) {
   });
 }
 
+// src/commands/whoami.ts
+init_esm_shims();
+
 // src/utils/auth-guard.ts
+init_esm_shims();
 function decodeJwtPayload(token) {
   try {
     const parts = token.split(".");
@@ -1286,6 +1997,12 @@ function registerWhoamiCommand(program2) {
     }
   });
 }
+
+// src/commands/create.ts
+init_esm_shims();
+
+// src/utils/linter-config.ts
+init_esm_shims();
 var ESLINT_CONFIGS = {
   react: {
     imports: ["baseConfig", "reactConfig"],
@@ -1354,6 +2071,9 @@ async function applyLinterConfig(targetDir, framework, linter, onProgress) {
   };
   await writeFile(targetPkgPath, JSON.stringify(targetPkg, null, 2));
 }
+
+// src/utils/alias-config.ts
+init_esm_shims();
 async function applyAliasConfig(targetDir, framework, aliasPrefix) {
   if (aliasPrefix === "@" || aliasPrefix === "@/") return;
   const config = {
@@ -1426,6 +2146,9 @@ async function updateImportsRecursive(dir, newPrefix, framework) {
     }
   }
 }
+
+// src/utils/api-client.ts
+init_esm_shims();
 function createAuthenticatedClient(accessToken) {
   const apiUrl = configManager.get("apiUrl") || DOCYRUS_API_URL;
   const client = new RestApiClient({ baseURL: apiUrl });
@@ -1441,6 +2164,9 @@ async function downloadOpenApiSpec(accessToken, targetDir, filename = "openapi.j
   await writeFile(targetPath, JSON.stringify(spec, null, 2));
   return targetPath;
 }
+
+// src/utils/ui-variant-swap.ts
+init_esm_shims();
 async function applyUIVariants(targetDir, uiLibrary) {
   const variantsDir = join(targetDir, "__ui-variants__");
   try {
@@ -1458,6 +2184,9 @@ async function applyUIVariants(targetDir, uiLibrary) {
   }
   await rm(variantsDir, { recursive: true, force: true });
 }
+
+// src/utils/ui-library-setup.ts
+init_esm_shims();
 var execAsync = promisify(exec);
 var DICEUI_COMPONENTS = "action-bar,avatar-group,badge-overflow,checkbox-group,circular-progress,color-picker,color-swatch,combobox,compare-slider,cropper,editable,file-upload,gauge,kanban,key-value,listbox,mask-input,media-player,mention,phone-input,qr-code,rating,relative-time-card,responsive-dialog,scroll-spy,scroller,segmented-input,sortable,speed-dial,stack,stat,status,stepper,swap,tags-input,time-picker,timeline,tour".split(",");
 var UI_LIBRARY_COMPATIBILITY = {
@@ -1707,6 +2436,9 @@ async function addHeroUIProviderReact(targetDir) {
   } catch {
   }
 }
+
+// src/utils/state-management-setup.ts
+init_esm_shims();
 var STATE_MANAGEMENT_VERSIONS = {
   zustand: { name: "zustand", version: "5.0.11" },
   "tanstack-query": { name: "@tanstack/react-query", version: "5.90.20" },
@@ -1901,7 +2633,7 @@ import { vueQueryOptions } from './lib/query-client';
 
 // src/commands/create.ts
 var execAsync2 = promisify(exec);
-var SHADCN_BASE_COLORS = "zinc,slate,neutral,stone,gray".split(",");
+var SHADCN_BASE_COLORS = "slate,gray,zinc,neutral,stone,red,orange,amber,yellow,lime,green,emerald,teal,cyan,sky".split(",");
 function validateConflictingFlags(options) {
   const frameworkFlags = [
     options.nextjs,
@@ -2069,13 +2801,13 @@ var PACKAGE_MANAGERS = [
   { name: "yarn", label: "yarn", description: "Fast, reliable, and secure" },
   { name: "bun", label: "bun", description: "All-in-one JavaScript runtime" }
 ];
-var TEMPLATE_REPO_BASE = "Docyrus/docyrus-devkit/templates";
+var TEMPLATE_REPO_BASE = "Docyrus/docyrus-ui/templates";
 function getTemplateRepo(framework) {
   return `${TEMPLATE_REPO_BASE}/${framework}`;
 }
-async function directoryExists(path) {
+async function directoryExists(path2) {
   try {
-    await access(path, constants.F_OK);
+    await access(path2, constants.F_OK);
     return true;
   } catch {
     return false;
@@ -2265,20 +2997,36 @@ Examples:
             );
           }
           await cp(localTemplateDir, targetDir, { recursive: true });
+          if (!process.env.DOCYRUS_DEVKIT_PATH) {
+            const { config } = await Promise.resolve().then(() => __toESM(require_main(), 1));
+            config({ path: resolve(cliPackageDir, "..", "..", ".env") });
+          }
           const pkgJsonPath = join(targetDir, "package.json");
           const pkgJson = JSON.parse(await readFile(pkgJsonPath, "utf-8"));
-          const packagesDir = resolve(cliPackageDir, "..");
+          const monorepoRoot = resolve(cliPackageDir, "..", "..");
+          const devkitPath = process.env.DOCYRUS_DEVKIT_PATH;
+          const packagesDirs = [
+            resolve(monorepoRoot, "packages"),
+            ...devkitPath ? [resolve(devkitPath, "packages")] : [resolve(monorepoRoot, "..", "docyrus-devkit", "packages")]
+          ];
           for (const depType of ["dependencies", "devDependencies"]) {
             const deps = pkgJson[depType];
             if (!deps) continue;
             for (const [name2, version] of Object.entries(deps)) {
               if (name2.startsWith("@docyrus/") && version === "latest") {
                 const pkgName = name2.replace("@docyrus/", "");
-                const localPkgDir = resolve(packagesDir, pkgName);
-                try {
-                  await access(localPkgDir, constants.F_OK);
-                  deps[name2] = `file:${localPkgDir}`;
-                } catch {
+                let found = false;
+                for (const packagesDir of packagesDirs) {
+                  const localPkgDir = resolve(packagesDir, pkgName);
+                  try {
+                    await access(localPkgDir, constants.F_OK);
+                    deps[name2] = `file:${localPkgDir}`;
+                    found = true;
+                    break;
+                  } catch {
+                  }
+                }
+                if (!found) {
                   logger.warn(`Local package not found for ${name2}, keeping "latest"`);
                 }
               }
@@ -2303,7 +3051,7 @@ Examples:
       await withSpinner(
         MESSAGES.CREATE_DOWNLOADING,
         async () => {
-          const gigetCachePath = resolve(homedir(), ".cache/giget/gh/Docyrus-docyrus-devkit");
+          const gigetCachePath = resolve(homedir(), ".cache/giget/gh/Docyrus-docyrus-ui");
           if (existsSync(gigetCachePath)) {
             await rm(gigetCachePath, { recursive: true, force: true });
           }
@@ -2455,8 +3203,11 @@ ${errorMessage}`
     logger.dim(MESSAGES.API_CLIENT_DOCS);
   });
 }
+
+// src/commands/generate.ts
+init_esm_shims();
 function registerGenerateCommand(program2) {
-  const generate = program2.command("generate").description("Code generation commands");
+  const generate = program2.command("generate").description("Generate code from OpenAPI specs (e.g. TanStack Query collections)");
   generate.command("api-spec").description("Download OpenAPI specification from Docyrus API").option("-o, --output <path>", "Output file path", "openapi.json").action(async (options) => {
     const token = await requireAuth();
     const outputPath = resolve(options.output);
@@ -2539,6 +3290,9 @@ function findSpecFile(specPath) {
   }
   return null;
 }
+
+// src/commands/upgrade.ts
+init_esm_shims();
 var execAsync3 = promisify(exec);
 async function getLatestVersion() {
   try {
@@ -2633,6 +3387,7 @@ function registerUpgradeCommand(program2) {
 }
 
 // src/commands/completion.ts
+init_esm_shims();
 var BASH_COMPLETION = `
 ###-begin-${CLI_NAME}-completions-###
 _${CLI_NAME}_completions() {
@@ -2641,11 +3396,11 @@ _${CLI_NAME}_completions() {
   args=("\${COMP_WORDS[@]}")
 
   # Commands
-  type_list="login logout whoami create generate upgrade completion info help"
+  type_list="login logout whoami create add commitlint generate upgrade completion info help"
 
   # Subcommands for generate
   if [[ \${args[1]} == "generate" ]]; then
-    type_list="db"
+    type_list="api-spec db"
   fi
 
   COMPREPLY=($(compgen -W "\${type_list}" -- \${cur_word}))
@@ -2663,15 +3418,18 @@ _${CLI_NAME}() {
     'logout:Log out from Docyrus'
     'whoami:Display the current logged-in user'
     'create:Create a new Docyrus project from template'
-    'generate:Code generation commands'
+    'generate:Generate code from OpenAPI specs'
     'upgrade:Upgrade Docyrus CLI to the latest version'
     'completion:Generate shell completion script'
+    'add:Add a component from the registry'
+    'commitlint:Set up commitlint, husky, and lint-staged'
     'info:Display CLI and environment information'
     'help:Display help for command'
   )
 
   local -a generate_commands
   generate_commands=(
+    'api-spec:Download OpenAPI specification from Docyrus API'
     'db:Generate TanStack Query collections from OpenAPI spec'
   )
 
@@ -2704,13 +3462,16 @@ complete -c ${CLI_NAME} -n "__fish_use_subcommand" -a "login" -d "Log in to Docy
 complete -c ${CLI_NAME} -n "__fish_use_subcommand" -a "logout" -d "Log out from Docyrus"
 complete -c ${CLI_NAME} -n "__fish_use_subcommand" -a "whoami" -d "Display the current logged-in user"
 complete -c ${CLI_NAME} -n "__fish_use_subcommand" -a "create" -d "Create a new Docyrus project"
-complete -c ${CLI_NAME} -n "__fish_use_subcommand" -a "generate" -d "Code generation commands"
+complete -c ${CLI_NAME} -n "__fish_use_subcommand" -a "generate" -d "Generate code from OpenAPI specs"
 complete -c ${CLI_NAME} -n "__fish_use_subcommand" -a "upgrade" -d "Upgrade Docyrus CLI"
 complete -c ${CLI_NAME} -n "__fish_use_subcommand" -a "completion" -d "Generate shell completion"
+complete -c ${CLI_NAME} -n "__fish_use_subcommand" -a "add" -d "Add a component from the registry"
+complete -c ${CLI_NAME} -n "__fish_use_subcommand" -a "commitlint" -d "Set up commitlint and husky"
 complete -c ${CLI_NAME} -n "__fish_use_subcommand" -a "info" -d "Display CLI and environment information"
 complete -c ${CLI_NAME} -n "__fish_use_subcommand" -a "help" -d "Display help"
 
 # generate subcommands
+complete -c ${CLI_NAME} -n "__fish_seen_subcommand_from generate" -a "api-spec" -d "Download OpenAPI specification"
 complete -c ${CLI_NAME} -n "__fish_seen_subcommand_from generate" -a "db" -d "Generate TanStack Query collections"
 ###-end-${CLI_NAME}-completions-###
 `.trim();
@@ -2752,6 +3513,9 @@ function registerCompletionCommand(program2) {
     }
   });
 }
+
+// src/commands/info.ts
+init_esm_shims();
 function registerInfoCommand(program2) {
   program2.command("info").description("Display CLI and environment information").action(async () => {
     const tokenManager = getTokenManager();
@@ -2804,18 +3568,40 @@ function registerInfoCommand(program2) {
     }
   });
 }
+
+// src/commands/config.ts
+init_esm_shims();
+function showConfig(isLoggedIn, email, githubToken) {
+  const currentTheme = configManager.get("helpTheme");
+  logger.log("Current configuration:");
+  logger.newline();
+  logger.log(`  Docyrus Login: ${isLoggedIn ? `\u2713 ${email}` : "\u2717 Not logged in"}`);
+  logger.log(`  Docyrus Token: ${githubToken ? "\u2713 Configured" : "\u2717 Not configured"}`);
+  logger.log(`  Help Theme:    ${currentTheme}`);
+  logger.newline();
+}
 function registerConfigCommand(program2) {
-  program2.command("config").description("Manage CLI configuration").option("--token", "Update Docyrus token for private template access").option("--show", "Show current configuration").action(async (options) => {
+  program2.command("config").description("Manage CLI configuration").option("--token", "Update Docyrus token for private template access").option("--theme", "Change help output color theme").option("--show", "Show current configuration").action(async (options) => {
     const tokenManager = getTokenManager();
     if (options.show) {
       const githubToken2 = await tokenManager.getGithubToken();
       const isLoggedIn2 = await tokenManager.isLoggedIn();
       const email2 = await tokenManager.getUserEmail();
-      logger.log("Current configuration:");
-      logger.newline();
-      logger.log(`  Docyrus Login: ${isLoggedIn2 ? `\u2713 ${email2}` : "\u2717 Not logged in"}`);
-      logger.log(`  Docyrus Token: ${githubToken2 ? "\u2713 Configured" : "\u2717 Not configured"}`);
-      logger.newline();
+      showConfig(isLoggedIn2, email2, githubToken2);
+      return;
+    }
+    if (options.theme) {
+      const currentTheme = configManager.get("helpTheme");
+      const theme = await select({
+        message: "Select help color theme:",
+        choices: HELP_THEMES.map((t) => ({
+          name: `${t.padEnd(12)} ${previewTheme(t)}`,
+          value: t
+        })),
+        default: currentTheme
+      });
+      configManager.set("helpTheme", theme);
+      logger.success(`Help theme set to "${theme}"`);
       return;
     }
     if (options.token) {
@@ -2838,12 +3624,786 @@ function registerConfigCommand(program2) {
     const githubToken = await tokenManager.getGithubToken();
     const isLoggedIn = await tokenManager.isLoggedIn();
     const email = await tokenManager.getUserEmail();
-    logger.log("Current configuration:");
+    showConfig(isLoggedIn, email, githubToken);
+    logger.log("To update token: docyrus config --token");
+    logger.log("To change theme: docyrus config --theme");
+  });
+}
+
+// src/commands/add.ts
+init_esm_shims();
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  throw new CliError(
+    "Could not find a package.json in the current directory or any parent directory.",
+    1,
+    "Run this command from within a JavaScript/TypeScript project."
+  );
+}
+async function readComponentsJson(projectRoot) {
+  const configPath = join(projectRoot, "components.json");
+  if (!existsSync(configPath)) {
+    throw new MissingConfigError();
+  }
+  const raw = await readFile(configPath, "utf-8");
+  return JSON.parse(raw);
+}
+function detectPackageManager2(projectRoot) {
+  if (existsSync(join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(projectRoot, "yarn.lock"))) return "yarn";
+  if (existsSync(join(projectRoot, "bun.lockb")) || existsSync(join(projectRoot, "bun.lock"))) return "bun";
+  return "npm";
+}
+function normalizeRegistryName(input4) {
+  if (input4.startsWith("@docyrus/")) return input4;
+  if (input4.startsWith("hooks-")) return `@docyrus/${input4}`;
+  if (input4.startsWith("utils-")) return `@docyrus/${input4}`;
+  return `@docyrus/ui-${input4}`;
+}
+async function fetchRegistryItem(name, token) {
+  const url = `${REGISTRY_BASE_URL}/${encodeURIComponent(name)}.json`;
+  const headers = {
+    Accept: "application/json"
+  };
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  let response;
+  try {
+    response = await fetch(url, { headers });
+  } catch {
+    throw new NetworkError();
+  }
+  if (response.status === 401 || response.status === 403) {
+    throw new PremiumAuthError(name);
+  }
+  if (response.status === 404) {
+    throw new ComponentNotFoundError(name);
+  }
+  if (!response.ok) {
+    throw new NetworkError(`Failed to fetch "${name}" from registry (HTTP ${response.status})`);
+  }
+  return response.json();
+}
+async function resolveAllDependencies(names, token) {
+  const resolved = /* @__PURE__ */ new Map();
+  const queue = [...names];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    if (resolved.has(name)) continue;
+    const item = await fetchRegistryItem(name, token);
+    resolved.set(name, item);
+    if (item.registryDependencies?.length > 0) {
+      for (const dep of item.registryDependencies) {
+        if (!resolved.has(dep)) {
+          queue.push(dep);
+        }
+      }
+    }
+  }
+  return resolved;
+}
+function resolveTargetDir(projectRoot) {
+  if (existsSync(join(projectRoot, "src"))) {
+    return join(projectRoot, "src");
+  }
+  return projectRoot;
+}
+async function writeItemFiles(item, baseDir, overwrite) {
+  const written = [];
+  for (const file of item.files) {
+    const targetPath = join(baseDir, file.path);
+    const targetDir = dirname(targetPath);
+    if (!existsSync(targetDir)) {
+      await mkdir(targetDir, { recursive: true });
+    }
+    if (existsSync(targetPath) && !overwrite) {
+      const shouldOverwrite = await confirm({
+        message: MESSAGES.ADD_FILE_EXISTS(file.path),
+        default: false
+      });
+      if (!shouldOverwrite) {
+        logger.dim(`  ${MESSAGES.ADD_FILE_SKIPPED(file.path)}`);
+        continue;
+      }
+    }
+    await writeFile(targetPath, file.content, "utf-8");
+    written.push(file.path);
+  }
+  return written;
+}
+async function getExistingDependencies(projectRoot) {
+  const pkgPath = join(projectRoot, "package.json");
+  try {
+    const raw = await readFile(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    const deps = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(pkg.dependencies || {})) {
+      deps.add(key);
+    }
+    for (const key of Object.keys(pkg.devDependencies || {})) {
+      deps.add(key);
+    }
+    return deps;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function installNpmDependencies(deps, projectRoot) {
+  if (deps.length === 0) return;
+  const pm = detectPackageManager2(projectRoot);
+  const pmArgs = {
+    npm: ["install", ...deps],
+    pnpm: ["add", ...deps],
+    yarn: ["add", ...deps],
+    bun: ["add", ...deps]
+  };
+  execFileSync(pm, pmArgs[pm], { cwd: projectRoot, stdio: "pipe" });
+}
+function handleDryRun(items, baseDir, allNewDeps) {
+  logger.newline();
+  logger.bold(MESSAGES.ADD_DRY_RUN_HEADER);
+  logger.newline();
+  for (const [name, item] of items) {
+    logger.info(`${item.title || name}`);
+    for (const file of item.files) {
+      const targetPath = join(baseDir, file.path);
+      const exists = existsSync(targetPath);
+      logger.dim(`  ${exists ? "(overwrite)" : "(create)"} ${file.path}`);
+    }
+  }
+  if (allNewDeps.length > 0) {
     logger.newline();
-    logger.log(`  Docyrus Login: ${isLoggedIn ? `\u2713 ${email}` : "\u2717 Not logged in"}`);
-    logger.log(`  Docyrus Token: ${githubToken ? "\u2713 Configured" : "\u2717 Not configured"}`);
+    logger.info("Dependencies to install:");
+    logger.dim(`  ${allNewDeps.join(", ")}`);
+  }
+  logger.newline();
+}
+function registerAddCommand(program2) {
+  program2.command("add [items...]").description("Add Docyrus UI components, hooks, or utilities to your project").option("-o, --overwrite", "Overwrite existing files without prompting").option("-d, --dry-run", "Show what would be installed without making changes").option("-p, --path <path>", "Custom target path for files").addHelpText("after", `
+Examples:
+  $ docyrus add button               Add a component
+  $ docyrus add button dialog         Add multiple components
+  $ docyrus add hooks-debounce        Add a hook
+  $ docyrus add utils-cn              Add a utility
+  $ docyrus add button --dry-run      Preview installation
+  $ docyrus add button -o             Overwrite existing files
+`).action(async (items, options) => {
+    if (!items || items.length === 0) {
+      throw new CliError(
+        MESSAGES.ADD_NO_ITEMS,
+        1,
+        "Usage: docyrus add <item...>\nExample: docyrus add button dialog hooks-debounce"
+      );
+    }
+    const projectRoot = findProjectRoot();
+    const config = await readComponentsJson(projectRoot);
+    const baseDir = options.path ? join(projectRoot, options.path) : resolveTargetDir(projectRoot);
     logger.newline();
-    logger.log("To update token: docyrus config --token");
+    logger.dim(MESSAGES.ADD_DETECTED_STYLE(config.style));
+    if (config.style.startsWith("base")) {
+      logger.warn(MESSAGES.ADD_DEPRECATED_BASE_STYLE);
+    }
+    let token;
+    try {
+      token = await requireAuth();
+    } catch {
+    }
+    const registryNames = items.map((item) => normalizeRegistryName(item));
+    const allItems = await withSpinner(
+      MESSAGES.ADD_RESOLVING,
+      () => resolveAllDependencies(registryNames, token),
+      { successText: `Resolved ${registryNames.length} item(s)` }
+    );
+    const existingDeps = await getExistingDependencies(projectRoot);
+    const allNewDeps = [];
+    for (const item of allItems.values()) {
+      for (const dep of item.dependencies) {
+        if (!existingDeps.has(dep) && !allNewDeps.includes(dep)) {
+          allNewDeps.push(dep);
+        }
+      }
+    }
+    if (options.dryRun) {
+      handleDryRun(allItems, baseDir, allNewDeps);
+      return;
+    }
+    let totalFiles = 0;
+    for (const [name, item] of allItems) {
+      const written = await withSpinner(
+        MESSAGES.ADD_INSTALLING_ITEM(item.title || name),
+        () => writeItemFiles(item, baseDir, !!options.overwrite),
+        { successText: `${item.title || name}` }
+      );
+      totalFiles += written.length;
+    }
+    if (allNewDeps.length > 0) {
+      await withSpinner(
+        MESSAGES.ADD_INSTALLING_DEPS(allNewDeps.length),
+        async () => installNpmDependencies(allNewDeps, projectRoot),
+        { successText: `${allNewDeps.length} dependenc${allNewDeps.length === 1 ? "y" : "ies"} installed` }
+      );
+    }
+    logger.newline();
+    logger.success(MESSAGES.ADD_SUCCESS(allItems.size, totalFiles));
+    if (allNewDeps.length > 0) {
+      logger.dim(`  Dependencies: ${allNewDeps.join(", ")}`);
+    }
+    logger.newline();
+  });
+}
+
+// src/commands/commitlint.ts
+init_esm_shims();
+
+// src/utils/commitlint-setup.ts
+init_esm_shims();
+function findProjectRoot2() {
+  let dir = process.cwd();
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  throw new CliError(
+    "Could not find a package.json.",
+    1,
+    "Run this command from within a JavaScript/TypeScript project."
+  );
+}
+function detectPackageManager3(projectRoot) {
+  if (existsSync(join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(projectRoot, "yarn.lock"))) return "yarn";
+  if (existsSync(join(projectRoot, "bun.lockb")) || existsSync(join(projectRoot, "bun.lock"))) return "bun";
+  return "npm";
+}
+async function detectWorkspaceScopes(projectRoot) {
+  const scopes = /* @__PURE__ */ new Set();
+  const pnpmPath = join(projectRoot, "pnpm-workspace.yaml");
+  if (existsSync(pnpmPath)) {
+    const content = await readFile(pnpmPath, "utf-8");
+    const patterns = content.split("\n").filter((line) => line.trim().startsWith("-")).map((line) => line.trim().replace(/^-\s*['"]?/, "").replace(/['"]?\s*$/, ""));
+    for (const pattern of patterns) {
+      const baseDir = pattern.replace(/\/?\*+$/, "");
+      const fullDir = join(projectRoot, baseDir);
+      if (existsSync(fullDir)) {
+        const entries = readdirSync(fullDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && !entry.name.startsWith(".")) {
+            scopes.add(entry.name);
+          }
+        }
+      }
+    }
+  }
+  try {
+    const pkg = JSON.parse(await readFile(join(projectRoot, "package.json"), "utf-8"));
+    const workspaces = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages ?? [];
+    for (const pattern of workspaces) {
+      const baseDir = pattern.replace(/\/?\*+$/, "");
+      const fullDir = join(projectRoot, baseDir);
+      if (existsSync(fullDir)) {
+        const entries = readdirSync(fullDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && !entry.name.startsWith(".")) {
+            scopes.add(entry.name);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  scopes.add("root");
+  scopes.add("deps");
+  scopes.add("release");
+  return [...scopes].sort();
+}
+function generateCommitlintConfig(opts) {
+  const { scopes, scopeStrategy } = opts;
+  let scopeRules = "";
+  if (scopeStrategy === "required") {
+    const scopeList = scopes.map((s) => `'${s}'`).join(", ");
+    scopeRules = `
+    // Scope required and must be from the allowed list
+    'scope-case': [2, 'always', 'lower-case'],
+    'scope-empty': [2, 'never'],
+    'scope-enum': [2, 'always', [${scopeList}]],`;
+  } else if (scopeStrategy === "optional") {
+    const scopeList = scopes.map((s) => `'${s}'`).join(", ");
+    scopeRules = `
+    // Scope optional but if present must be from the allowed list
+    'scope-case': [2, 'always', 'lower-case'],
+    'scope-empty': [0],
+    'scope-enum': [2, 'always', [${scopeList}]],`;
+  }
+  return `import { type UserConfig } from '@commitlint/types';
+
+const config: UserConfig = {
+  extends: ['@commitlint/config-conventional'],
+  rules: {
+    // Type required
+    'type-empty': [2, 'never'],
+
+    // Subject required with length constraints
+    'subject-empty': [2, 'never'],
+    'subject-min-length': [2, 'always', 5],
+    'subject-max-length': [2, 'always', 250],
+
+    // Header max length
+    'header-max-length': [2, 'always', 100],
+${scopeRules}
+    // Body (disabled \u2014 no line length limit)
+    'body-max-line-length': [0, 'always', 200],
+
+    // BREAKING CHANGE (disabled by default)
+    'trailer-exists': [0, 'always', 'BREAKING CHANGE']
+  },
+
+  parserPreset: {
+    parserOpts: {
+      breakingHeaderPattern: /^(\\w*)(?:\\((.*)\\))?!: (.*)$/,
+      noteKeywords: ['BREAKING CHANGE']
+    }
+  },
+
+  helpUrl:
+    'https://github.com/conventional-changelog/commitlint/#what-is-commitlint'
+};
+
+export default config;
+`;
+}
+function generateCommitMsgHook(packageManager) {
+  const exec4 = packageManager === "pnpm" ? "pnpm exec" : packageManager === "yarn" ? "yarn" : packageManager === "bun" ? "bunx" : "npx --no-install";
+  return `${exec4} commitlint --edit $1
+`;
+}
+function generatePreCommitHook() {
+  return `# Skip if no code files are staged
+if git diff --cached --name-only | grep -qE '\\.(ts|tsx|js|jsx)$'; then
+  npx --no-install lint-staged
+fi
+`;
+}
+function generateCommitLinterScript() {
+  return `#!/usr/bin/env bash
+# Monorepo-aware tsc-files: finds the nearest tsconfig.json for each file,
+# groups files by their tsconfig directory, and runs tsc per group.
+
+if [ $# -eq 0 ]; then
+  exit 0
+fi
+
+node -e "
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const files = process.argv.slice(1).map(f => path.resolve(f));
+const groups = {};
+
+for (const file of files) {
+  let dir = path.dirname(file);
+  let tsconfigDir = null;
+
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, 'tsconfig.json'))) {
+      tsconfigDir = dir;
+      break;
+    }
+    dir = path.dirname(dir);
+  }
+
+  if (!tsconfigDir) continue;
+  if (!groups[tsconfigDir]) groups[tsconfigDir] = [];
+  groups[tsconfigDir].push(file);
+}
+
+let failed = false;
+
+for (const [dir, groupFiles] of Object.entries(groups)) {
+  const configPath = path.join(dir, 'tsconfig.json');
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  const tmpName = 'tsconfig.staged-' + process.pid + '.json';
+  const tmpPath = path.join(dir, tmpName);
+
+  const excludePatterns = (config.exclude || []).map(p => p.replace(/\\\\/\\\\*\\\\*.*$/, '').replace(/\\\\/$/, ''));
+  const filteredFiles = groupFiles.filter(f => {
+    const rel = path.relative(dir, f).replace(/\\\\\\\\\\\\\\\\/g, '/');
+    return !excludePatterns.some(p => rel === p || rel.startsWith(p + '/'));
+  });
+  if (filteredFiles.length === 0) continue;
+
+  const tmpConfig = {
+    ...config,
+    compilerOptions: { ...config.compilerOptions, skipLibCheck: true, rootDir: undefined },
+    files: filteredFiles,
+    include: []
+  };
+  delete tmpConfig.compilerOptions.rootDir;
+
+  fs.writeFileSync(tmpPath, JSON.stringify(tmpConfig, null, 2));
+
+  try {
+    execFileSync('npx', ['--no-install', 'tsc', '-p', tmpName, '--noEmit'], { cwd: dir, stdio: 'inherit' });
+  } catch {
+    failed = true;
+  } finally {
+    fs.unlinkSync(tmpPath);
+  }
+}
+
+if (failed) process.exit(1);
+" "$@"
+
+exit $?
+`;
+}
+async function updatePackageJson(projectRoot) {
+  const pkgPath = join(projectRoot, "package.json");
+  const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+  pkg.devDependencies = {
+    ...pkg.devDependencies,
+    "@commitlint/cli": "latest",
+    "@commitlint/config-conventional": "latest",
+    "@commitlint/types": "latest",
+    husky: "latest",
+    "lint-staged": "latest"
+  };
+  pkg.scripts = pkg.scripts ?? {};
+  if (pkg.scripts.prepare && !pkg.scripts.prepare.includes("husky")) {
+    pkg.scripts.prepare = `${pkg.scripts.prepare} && husky`;
+  } else if (!pkg.scripts.prepare) {
+    pkg.scripts.prepare = "husky";
+  }
+  pkg["lint-staged"] = {
+    "*.{ts,tsx}": ["bash scripts/commit-linter.sh", "eslint --fix"]
+  };
+  await writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf-8");
+}
+async function writeCommitlintFiles(opts) {
+  const {
+    projectRoot,
+    scopes,
+    scopeStrategy,
+    packageManager
+  } = opts;
+  await writeFile(
+    join(projectRoot, "commitlint.config.ts"),
+    generateCommitlintConfig({ scopes, scopeStrategy }),
+    "utf-8"
+  );
+  const huskyDir = join(projectRoot, ".husky");
+  if (!existsSync(huskyDir)) {
+    await mkdir(huskyDir, { recursive: true });
+  }
+  await writeFile(join(huskyDir, "commit-msg"), generateCommitMsgHook(packageManager), "utf-8");
+  await writeFile(join(huskyDir, "pre-commit"), generatePreCommitHook(), "utf-8");
+  const scriptsDir = join(projectRoot, "scripts");
+  if (!existsSync(scriptsDir)) {
+    await mkdir(scriptsDir, { recursive: true });
+  }
+  const scriptPath = join(scriptsDir, "commit-linter.sh");
+  await writeFile(scriptPath, generateCommitLinterScript(), "utf-8");
+  await chmod(scriptPath, "755");
+}
+function installDeps(projectRoot, packageManager) {
+  execFileSync(packageManager, ["install"], {
+    cwd: projectRoot,
+    stdio: "pipe"
+  });
+}
+function initHusky(projectRoot, packageManager) {
+  const cmds = {
+    pnpm: ["pnpm", ["exec", "husky"]],
+    npm: ["npx", ["husky"]],
+    yarn: ["yarn", ["husky"]],
+    bun: ["bunx", ["husky"]]
+  };
+  const [cmd, args] = cmds[packageManager];
+  execFileSync(cmd, args, {
+    cwd: projectRoot,
+    stdio: "pipe"
+  });
+}
+
+// src/commands/commitlint.ts
+function registerCommitlintCommand(program2) {
+  program2.command("commitlint").description(MESSAGES.COMMITLINT_DESCRIPTION).option("--scopes <scopes>", "Comma-separated list of scopes").option("--monorepo", "Treat as monorepo").option("--no-monorepo", "Treat as single project").option("--scope-strategy <strategy>", "Scope strategy: required, optional, none").option("-y, --yes", "Accept defaults and overwrite existing files").action(async (options) => {
+    const projectRoot = findProjectRoot2();
+    const packageManager = detectPackageManager3(projectRoot);
+    logger.newline();
+    logger.dim(MESSAGES.COMMITLINT_DETECTED_PM(packageManager));
+    const configExists = existsSync(join(projectRoot, "commitlint.config.ts"));
+    const huskyExists = existsSync(join(projectRoot, ".husky"));
+    if (configExists && !options.yes) {
+      const overwrite = await confirm({
+        message: MESSAGES.COMMITLINT_CONFIG_EXISTS,
+        default: false
+      });
+      if (!overwrite) {
+        logger.dim("Aborted.");
+        return;
+      }
+    }
+    let skipHusky = false;
+    if (huskyExists && !options.yes) {
+      const overwrite = await confirm({
+        message: MESSAGES.COMMITLINT_HUSKY_EXISTS,
+        default: true
+      });
+      skipHusky = !overwrite;
+    }
+    const isMonorepo = options.monorepo !== void 0 ? options.monorepo : await confirm({
+      message: MESSAGES.COMMITLINT_IS_MONOREPO,
+      default: false
+    });
+    let scopeStrategy;
+    if (options.scopeStrategy) {
+      scopeStrategy = options.scopeStrategy;
+    } else {
+      scopeStrategy = await select({
+        message: MESSAGES.COMMITLINT_SCOPE_STRATEGY,
+        choices: [
+          {
+            name: isMonorepo ? "Required (recommended)" : "Required",
+            value: "required",
+            description: "fix(auth): ... \u2014 scope is mandatory"
+          },
+          {
+            name: isMonorepo ? "Optional" : "Optional (recommended)",
+            value: "optional",
+            description: "fix: ... or fix(auth): ... \u2014 both valid"
+          },
+          {
+            name: "None",
+            value: "none",
+            description: "fix: ... \u2014 scopes are not used"
+          }
+        ],
+        default: isMonorepo ? "required" : "optional"
+      });
+    }
+    let scopes = [];
+    if (scopeStrategy !== "none") {
+      if (options.scopes) {
+        scopes = options.scopes.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+      } else {
+        if (isMonorepo) {
+          const detected = await detectWorkspaceScopes(projectRoot);
+          if (detected.length > 0) {
+            logger.dim(MESSAGES.COMMITLINT_DETECTED_WORKSPACES(detected.length));
+            scopes = await checkbox({
+              message: MESSAGES.COMMITLINT_SELECT_SCOPES,
+              choices: detected.map((s) => ({
+                name: s,
+                value: s,
+                checked: true
+              }))
+            });
+          } else {
+            logger.warn(MESSAGES.COMMITLINT_NO_WORKSPACES);
+            scopes = [
+              "root",
+              "deps",
+              "release"
+            ];
+          }
+        } else {
+          scopes = [
+            "root",
+            "deps",
+            "release"
+          ];
+        }
+        const additional = await input({
+          message: MESSAGES.COMMITLINT_ADDITIONAL_SCOPES
+        });
+        if (additional.trim()) {
+          const extra = additional.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+          for (const s of extra) {
+            if (!scopes.includes(s)) {
+              scopes.push(s);
+            }
+          }
+        }
+      }
+      scopes.sort();
+      logger.newline();
+      logger.info(MESSAGES.COMMITLINT_CONFIRM_SCOPES(scopes));
+    }
+    logger.newline();
+    const progress = createMultiStepProgress("Setting up Commitlint", [
+      MESSAGES.COMMITLINT_STEP_CONFIG,
+      MESSAGES.COMMITLINT_STEP_HUSKY,
+      MESSAGES.COMMITLINT_STEP_SCRIPT,
+      MESSAGES.COMMITLINT_STEP_PACKAGE_JSON,
+      MESSAGES.COMMITLINT_STEP_INSTALL,
+      MESSAGES.COMMITLINT_STEP_INIT_HUSKY
+    ]);
+    progress.start(0);
+    await writeCommitlintFiles({
+      projectRoot,
+      scopes,
+      scopeStrategy,
+      packageManager
+    });
+    progress.complete(0);
+    if (skipHusky) {
+      progress.complete(1);
+    } else {
+      progress.start(1);
+      progress.complete(1);
+    }
+    progress.start(2);
+    progress.complete(2);
+    progress.start(3);
+    await updatePackageJson(projectRoot);
+    progress.complete(3);
+    progress.start(4);
+    try {
+      installDeps(projectRoot, packageManager);
+      progress.complete(4);
+    } catch (error) {
+      progress.fail(4, error instanceof Error ? error.message : "Failed to install dependencies");
+      progress.finish();
+      throw error;
+    }
+    progress.start(5);
+    try {
+      initHusky(projectRoot, packageManager);
+      progress.complete(5);
+    } catch (error) {
+      progress.fail(5, error instanceof Error ? error.message : "Failed to initialize husky");
+      progress.finish();
+      throw error;
+    }
+    progress.finish();
+    logger.newline();
+    logger.success(MESSAGES.COMMITLINT_SUCCESS);
+    logger.dim(MESSAGES.COMMITLINT_SUCCESS_HINT);
+    logger.newline();
+  });
+}
+
+// src/commands/list.ts
+init_esm_shims();
+async function fetchRegistryIndex() {
+  const url = `${REGISTRY_BASE_URL}/__index.json`;
+  let response;
+  try {
+    response = await fetch(url, { headers: { Accept: "application/json" } });
+  } catch {
+    throw new NetworkError();
+  }
+  if (!response.ok) {
+    throw new NetworkError(`Failed to fetch registry index (HTTP ${response.status})`);
+  }
+  return response.json();
+}
+async function fetchNpmPackages() {
+  const url = "https://registry.npmjs.org/-/v1/search?text=%40docyrus&size=100";
+  let response;
+  try {
+    response = await fetch(url, { headers: { Accept: "application/json" } });
+  } catch {
+    throw new NetworkError();
+  }
+  if (!response.ok) {
+    throw new NetworkError(`Failed to fetch npm packages (HTTP ${response.status})`);
+  }
+  const data = await response.json();
+  return data.objects.map((o) => ({
+    name: o.package.name,
+    version: o.package.version,
+    description: o.package.description,
+    date: o.package.date
+  }));
+}
+function groupByType(items) {
+  const groups = {};
+  for (const item of items) {
+    const category = item.type.replace("registry:", "");
+    const group = groups[category] ??= [];
+    group.push(item);
+  }
+  return groups;
+}
+function printRegistryList(items) {
+  const groups = groupByType(items);
+  const categoryLabels = {
+    ui: "Components",
+    hook: "Hooks",
+    lib: "Utilities"
+  };
+  logger.newline();
+  logger.bold(MESSAGES.LIST_HEADER);
+  logger.newline();
+  for (const [type, group] of Object.entries(groups)) {
+    const label = categoryLabels[type] || type;
+    logger.info(chalk4.bold(label));
+    for (const item of group) {
+      const name = chalk4.cyan(item.name);
+      const desc = item.description ? chalk4.dim(` \u2014 ${item.description}`) : "";
+      logger.log(`  ${name}${desc}`);
+    }
+    logger.newline();
+  }
+  logger.dim(MESSAGES.LIST_INSTALL_HINT);
+  logger.newline();
+}
+function printNpmPackages(packages) {
+  logger.newline();
+  logger.bold(MESSAGES.LIST_NPM_HEADER);
+  logger.newline();
+  for (const pkg of packages) {
+    const name = chalk4.cyan(pkg.name);
+    const version = chalk4.dim(`@${pkg.version}`);
+    const desc = pkg.description ? chalk4.dim(` \u2014 ${pkg.description}`) : "";
+    logger.log(`  ${name}${version}${desc}`);
+  }
+  logger.dim(`
+  ${MESSAGES.LIST_NPM_LINK}`);
+  logger.newline();
+}
+function registerListCommand(program2) {
+  program2.command("list").alias("ls").description("List available Docyrus UI components, hooks, and utilities").option("--packages", "List published @docyrus npm packages instead").addHelpText("after", `
+Examples:
+  $ docyrus list                List registry components
+  $ docyrus ls                  Shorthand alias
+  $ docyrus list --packages     List published npm packages
+  $ docyrus list --json         Output as JSON
+`).action(async (options) => {
+    if (options.packages) {
+      const packages = await withSpinner(
+        MESSAGES.LIST_FETCHING_NPM,
+        fetchNpmPackages,
+        { successText: MESSAGES.LIST_NPM_SUCCESS }
+      );
+      if (output.isJson()) {
+        output.success("ok", { packages });
+      } else {
+        printNpmPackages(packages);
+      }
+    } else {
+      const items = await withSpinner(
+        MESSAGES.LIST_FETCHING,
+        fetchRegistryIndex
+      );
+      if (output.isJson()) {
+        output.success("ok", { items });
+      } else {
+        printRegistryList(items);
+      }
+    }
   });
 }
 
@@ -2853,12 +4413,18 @@ function registerCommands(program2) {
   registerLogoutCommand(program2);
   registerWhoamiCommand(program2);
   registerCreateCommand(program2);
+  registerAddCommand(program2);
+  registerListCommand(program2);
+  registerCommitlintCommand(program2);
   registerGenerateCommand(program2);
   registerUpgradeCommand(program2);
   registerCompletionCommand(program2);
   registerInfoCommand(program2);
   registerConfigCommand(program2);
 }
+
+// src/utils/update-checker.ts
+init_esm_shims();
 function isNewerVersion2(current, latest) {
   const currentParts = current.replace(/^v/, "").split(".").map(Number);
   const latestParts = latest.replace(/^v/, "").split(".").map(Number);
@@ -2896,7 +4462,7 @@ async function checkForUpdates(packageName, currentVersion) {
 
 // src/cli.ts
 var program = new Command();
-program.name(CLI_NAME).description("Docyrus CLI - Authentication and project management tools").version(CLI_VERSION, "-v, --version", "Display version number").option("--json", "Output results in JSON format").hook("preAction", (thisCommand) => {
+program.name(CLI_NAME).description("Docyrus CLI - Authentication and project management tools").version(CLI_VERSION, "-v, --version", "Display version number").option("--json", "Output results in JSON format").configureHelp(getHelpConfig(configManager.get("helpTheme"))).hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
   if (opts.json) {
     output.setFormat("json");