@docyrus/cli 0.4.0 → 0.5.0

package/dist/cli.js

@@ -6,15 +6,15 @@ import { RestApiClient, AuthenticationError as AuthenticationError$1 } from '@do
 import { createServer } from 'http';
 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 { 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 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';
 
@@ -57,12 +57,12 @@ var init_esm_shims = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/dotenv@17.2.4/node_modules/dotenv/package.json
+// ../../node_modules/.pnpm/dotenv@17.3.1/node_modules/dotenv/package.json
 var require_package = __commonJS({
-  "../../node_modules/.pnpm/dotenv@17.2.4/node_modules/dotenv/package.json"(exports$1, module) {
+  "../../node_modules/.pnpm/dotenv@17.3.1/node_modules/dotenv/package.json"(exports$1, module) {
     module.exports = {
       name: "dotenv",
-      version: "17.2.4",
+      version: "17.3.1",
       description: "Loads environment variables from .env file",
       main: "lib/main.js",
       types: "lib/main.d.ts",
@@ -125,9 +125,9 @@ var require_package = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/dotenv@17.2.4/node_modules/dotenv/lib/main.js
+// ../../node_modules/.pnpm/dotenv@17.3.1/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) {
+  "../../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");
@@ -139,12 +139,9 @@ var require_main = __commonJS({
       "\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{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 }",
@@ -1310,7 +1307,8 @@ init_esm_shims();
 // src/config/config-manager.ts
 init_esm_shims();
 var defaults = {
-  telemetryEnabled: true
+  telemetryEnabled: true,
+  helpTheme: "default"
 };
 var ConfigManager = class {
   config;
@@ -1551,13 +1549,43 @@ var MESSAGES = {
   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-*).'
+  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"
   });
@@ -1614,12 +1642,77 @@ 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) => {
@@ -1628,7 +1721,7 @@ function createSimpleProgress() {
       spinner = null;
     }
     const text = current && total ? `${step} (${current}/${total})` : step;
-    spinner = ora({
+    spinner = ora2({
       text,
       color: "cyan"
     }).start();
@@ -1639,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");
@@ -3049,7 +3207,7 @@ ${errorMessage}`
 // 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);
@@ -3238,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}))
@@ -3260,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'
   )
 
@@ -3301,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();
@@ -3407,18 +3571,37 @@ 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) {
@@ -3441,12 +3624,9 @@ function registerConfigCommand(program2) {
     const githubToken = await tokenManager.getGithubToken();
     const isLoggedIn = await tokenManager.isLoggedIn();
     const email = await tokenManager.getUserEmail();
-    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.newline();
+    showConfig(isLoggedIn, email, githubToken);
     logger.log("To update token: docyrus config --token");
+    logger.log("To change theme: docyrus config --theme");
   });
 }
 
@@ -3480,11 +3660,11 @@ function detectPackageManager2(projectRoot) {
   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}`;
+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`;
@@ -3679,6 +3859,554 @@ Examples:
   });
 }
 
+// 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);
+      }
+    }
+  });
+}
+
 // src/commands/index.ts
 function registerCommands(program2) {
   registerLoginCommand(program2);
@@ -3686,6 +4414,8 @@ function registerCommands(program2) {
   registerWhoamiCommand(program2);
   registerCreateCommand(program2);
   registerAddCommand(program2);
+  registerListCommand(program2);
+  registerCommitlintCommand(program2);
   registerGenerateCommand(program2);
   registerUpgradeCommand(program2);
   registerCompletionCommand(program2);
@@ -3732,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");