@docyrus/cli 0.3.1 → 0.4.0

package/dist/cli.js

@@ -1,25 +1,478 @@
 #!/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 { 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 { exec, execFileSync } from 'child_process';
 import { promisify } from 'util';
 import { access, constants, writeFile, readFile, mkdir, 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.2.4/node_modules/dotenv/package.json
+var require_package = __commonJS({
+  "../../node_modules/.pnpm/dotenv@17.2.4/node_modules/dotenv/package.json"(exports$1, module) {
+    module.exports = {
+      name: "dotenv",
+      version: "17.2.4",
+      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.2.4/node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "../../node_modules/.pnpm/dotenv@17.2.4/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{1F4E1} add observability to secrets: https://dotenvx.com/ops",
+      "\u{1F465} sync secrets across teammates & machines: https://dotenvx.com/ops",
+      "\u{1F5C2}\uFE0F backup and recover secrets: https://dotenvx.com/ops",
+      "\u2705 audit secrets and track compliance: https://dotenvx.com/ops",
+      "\u{1F504} add secrets lifecycle management: https://dotenvx.com/ops",
+      "\u{1F511} add access controls to secrets: https://dotenvx.com/ops",
+      "\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 +489,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 +562,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 +680,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 +868,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 +912,9 @@ async function startCallbackServer(expectedState) {
     cleanup
   };
 }
+
+// src/utils/browser.ts
+init_esm_shims();
 async function openBrowser(url) {
   await open(url);
 }
@@ -505,12 +999,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 +1132,7 @@ var FileStorage = class {
 };
 
 // src/storage/keychain-storage.ts
+init_esm_shims();
 var keytar = null;
 async function getKeytar() {
   if (keytar !== null) {
@@ -696,6 +1203,7 @@ var KeychainStorage = class {
 };
 
 // src/storage/cli-token-manager.ts
+init_esm_shims();
 var CliTokenManager = class {
   keychain;
   fileStorage;
@@ -795,6 +1303,12 @@ function getTokenManager() {
   }
   return instance;
 }
+
+// src/config/index.ts
+init_esm_shims();
+
+// src/config/config-manager.ts
+init_esm_shims();
 var defaults = {
   telemetryEnabled: true
 };
@@ -826,6 +1340,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 +1380,9 @@ var logger = {
     return chalk4.cyan.underline(url);
   }
 };
+
+// src/ui/output.ts
+init_esm_shims();
 var state = {
   format: "text",
   data: {}
@@ -944,6 +1467,7 @@ var output = {
 };
 
 // src/ui/messages.ts
+init_esm_shims();
 var MESSAGES = {
   // Login
   LOGIN_SUCCESS: (email) => `Successfully logged in as ${email}`,
@@ -990,7 +1514,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,8 +1536,26 @@ 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-*).'
 };
+
+// src/ui/spinner.ts
+init_esm_shims();
 function createSpinner(text) {
   return ora({
     text,
@@ -1042,6 +1584,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,6 +1611,9 @@ async function promptPassword() {
     }
   });
 }
+
+// src/ui/progress.ts
+init_esm_shims();
 ({
   pending: chalk4.dim("\u25CB"),
   in_progress: chalk4.cyan("\u25D0"),
@@ -1170,6 +1718,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 +1741,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 +1839,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 +1913,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 +1988,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 +2006,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 +2026,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 +2278,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 +2475,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 +2643,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 +2839,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 +2893,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,6 +3045,9 @@ ${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");
   generate.command("api-spec").description("Download OpenAPI specification from Docyrus API").option("-o, --output <path>", "Output file path", "openapi.json").action(async (options) => {
@@ -2539,6 +3132,9 @@ function findSpecFile(specPath) {
   }
   return null;
 }
+
+// src/commands/upgrade.ts
+init_esm_shims();
 var execAsync3 = promisify(exec);
 async function getLatestVersion() {
   try {
@@ -2633,6 +3229,7 @@ function registerUpgradeCommand(program2) {
 }
 
 // src/commands/completion.ts
+init_esm_shims();
 var BASH_COMPLETION = `
 ###-begin-${CLI_NAME}-completions-###
 _${CLI_NAME}_completions() {
@@ -2752,6 +3349,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,6 +3404,9 @@ function registerInfoCommand(program2) {
     }
   });
 }
+
+// src/commands/config.ts
+init_esm_shims();
 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) => {
     const tokenManager = getTokenManager();
@@ -2847,18 +3450,251 @@ function registerConfigCommand(program2) {
   });
 }
 
+// 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(input3) {
+  if (input3.startsWith("@docyrus/")) return input3;
+  if (input3.startsWith("hooks-")) return `@docyrus/${input3}`;
+  if (input3.startsWith("utils-")) return `@docyrus/${input3}`;
+  return `@docyrus/ui-${input3}`;
+}
+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.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.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/index.ts
 function registerCommands(program2) {
   registerLoginCommand(program2);
   registerLogoutCommand(program2);
   registerWhoamiCommand(program2);
   registerCreateCommand(program2);
+  registerAddCommand(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);