@dsai-io/tools 1.0.7 → 1.2.1

package/dist/cli/index.js

@@ -1,12 +1,13 @@
 import * as fs3 from 'fs';
-import { existsSync, readFileSync, readdirSync, statSync, writeFileSync, mkdirSync, rmSync, copyFileSync } from 'fs';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync, statSync, rmSync, copyFileSync } from 'fs';
 import * as path4 from 'path';
-import path4__default, { relative, basename, extname, join, dirname, parse, resolve } from 'path';
+import path4__default, { resolve, join, basename, dirname, relative, extname, parse } from 'path';
 import { z } from 'zod';
 import { createHash } from 'crypto';
 import fg from 'fast-glob';
-import { execSync } from 'child_process';
+import { execFileSync, execSync } from 'child_process';
 import { readFile, writeFile } from 'fs/promises';
+import { fileURLToPath } from 'url';
 import { Command } from 'commander';
 import { cosmiconfig } from 'cosmiconfig';
 import e from 'picocolors';
@@ -4385,20 +4386,6 @@ var init_line_height = __esm({
   }
 });
 
-// src/tokens/style-dictionary/transforms/name.ts
-var nameKebab;
-var init_name = __esm({
-  "src/tokens/style-dictionary/transforms/name.ts"() {
-    nameKebab = {
-      name: "name/kebab",
-      type: "name",
-      transform: (token) => {
-        return token.path.join("-").replace(/_/g, "-").toLowerCase();
-      }
-    };
-  }
-});
-
 // src/tokens/style-dictionary/transforms/name-js-identifier.ts
 function toPascalCaseSegment3(segment) {
   const needsNumericPrefix = /^\d/.test(segment);
@@ -4418,6 +4405,20 @@ var init_name_js_identifier = __esm({
   }
 });
 
+// src/tokens/style-dictionary/transforms/name.ts
+var nameKebab;
+var init_name = __esm({
+  "src/tokens/style-dictionary/transforms/name.ts"() {
+    nameKebab = {
+      name: "name/kebab",
+      type: "name",
+      transform: (token) => {
+        return token.path.join("-").replace(/_/g, "-").toLowerCase();
+      }
+    };
+  }
+});
+
 // src/tokens/style-dictionary/transforms/index.ts
 var transforms_exports = {};
 __export(transforms_exports, {
@@ -4446,8 +4447,8 @@ var init_transforms = __esm({
     init_dimension();
     init_font_weight();
     init_line_height();
-    init_name();
     init_name_js_identifier();
+    init_name();
     init_font_weight();
     init_line_height();
     init_dimension();
@@ -7877,494 +7878,225 @@ var require_src = __commonJS({
     module.exports = { cursor, scroll, erase, beep };
   }
 });
-var logLevelSchema = z.enum(["silent", "error", "warn", "info", "debug", "verbose"]);
-var outputFormatSchema = z.enum(["css", "scss", "less", "json", "js", "ts", "esm", "cjs"]);
-var frameworkSchema = z.enum(["react", "vue", "angular", "svelte", "vanilla"]);
-var hashTypeSchema = z.enum(["content", "timestamp", "version", "none"]);
-z.string().min(1, "Glob pattern cannot be empty");
-z.string().min(1, "File path cannot be empty");
-z.string().refine(
-  (val) => {
-    const parts = val.split("-");
-    const version2 = parts[0] ?? "";
-    const preRelease = parts[1];
-    const versionParts = version2.split(".");
-    if (versionParts.length !== 3) {
-      return false;
+
+// src/config/defaults.ts
+var DEFAULT_PREFIX = "--dsai-";
+var DEFAULT_LOG_LEVEL = "info";
+var DEFAULT_OUTPUT_DIR = "dist";
+var DEFAULT_SOURCE_DIR = "figma-exports";
+var DEFAULT_COLLECTIONS_DIR = "collections";
+var DEFAULT_ICONS_SOURCE_DIR = "icons";
+var DEFAULT_ICONS_OUTPUT_DIR = "dist/icons";
+var defaultSourcePatterns = ["theme.json", "tokens.json", "*.tokens.json"];
+var defaultFormats = ["css", "scss", "js", "ts", "json"];
+var defaultOutputFileNames = {
+  css: "tokens.css",
+  scss: "_tokens.scss",
+  js: "tokens.js",
+  ts: "tokens.ts",
+  json: "tokens.json",
+  android: "tokens.xml",
+  ios: "tokens.h"
+};
+var defaultSelectorPattern = {
+  default: ":root",
+  others: '[data-dsai-theme="{mode}"]'
+};
+var defaultThemeDefinitions = {
+  light: {
+    isDefault: true,
+    suffix: null,
+    selector: ":root",
+    outputFiles: {
+      css: "tokens.css",
+      scss: "_tokens.scss",
+      js: "tokens.js",
+      ts: "tokens.ts",
+      json: "tokens.json",
+      android: "tokens.xml",
+      ios: "tokens.h"
     }
-    for (const part of versionParts) {
-      const num = Number(part);
-      if (!Number.isInteger(num) || num < 0) {
-        return false;
+  },
+  dark: {
+    isDefault: false,
+    suffix: "-dark",
+    selector: '[data-dsai-theme="dark"]',
+    mediaQuery: "(prefers-color-scheme: dark)",
+    outputFiles: {
+      css: "tokens-dark.css",
+      scss: "_tokens-dark.scss",
+      js: "tokens-dark.js",
+      ts: "tokens-dark.ts",
+      json: "tokens-dark.json",
+      android: "tokens-dark.xml",
+      ios: "tokens-dark.h"
+    }
+  }
+};
+var defaultThemesConfig = {
+  enabled: true,
+  autoDetect: true,
+  default: "light",
+  ignoreModes: [],
+  selectorPattern: defaultSelectorPattern};
+var defaultIconFramework = "react";
+var defaultIconsConfig = {
+  sourceDir: DEFAULT_ICONS_SOURCE_DIR,
+  outputDir: DEFAULT_ICONS_OUTPUT_DIR,
+  framework: defaultIconFramework,
+  typescript: true,
+  optimize: true,
+  prefix: "Icon"
+};
+var defaultAliasesConfig = {
+  importAlias: "@/",
+  ui: "src/components/ui",
+  hooks: "src/hooks",
+  utils: "src/lib/utils",
+  components: "src/components",
+  lib: "src/lib"
+};
+var defaultComponentsConfig = {
+  enabled: true,
+  registryUrl: "https://registry.dsai.dev",
+  tsx: true,
+  overwrite: false
+};
+var defaultTokensConfig = {
+  source: "theme",
+  sourceDir: DEFAULT_SOURCE_DIR,
+  collectionsDir: DEFAULT_COLLECTIONS_DIR,
+  sourcePatterns: defaultSourcePatterns,
+  outputDir: DEFAULT_OUTPUT_DIR,
+  outputDirs: {},
+  outputFileNames: defaultOutputFileNames,
+  prefix: DEFAULT_PREFIX,
+  formats: defaultFormats,
+  mergeOrder: "after",
+  createBundle: false,
+  outputReferences: true,
+  baseFontSize: 16,
+  separateThemeFiles: false,
+  watch: false};
+var defaultGlobalConfig = {
+  cwd: process.cwd(),
+  debug: false,
+  logLevel: DEFAULT_LOG_LEVEL
+};
+({
+  configDir: process.cwd()
+});
+
+// src/config/resolver.ts
+function resolveGlobalConfig(config, options) {
+  const base = defaultGlobalConfig;
+  const cwd = options.cwd ?? process.cwd();
+  return {
+    cwd: config?.cwd ? path4__default.resolve(cwd, config.cwd) : cwd,
+    debug: config?.debug ?? base.debug,
+    logLevel: config?.logLevel ?? base.logLevel
+  };
+}
+function resolveThemeDefinition(themeName, definition, selectorPattern, _outputFileNames, isDefaultTheme) {
+  const generateOutputFiles = () => {
+    const suffix = isDefaultTheme ? "" : `-${themeName}`;
+    return {
+      css: `tokens${suffix}.css`,
+      scss: `_tokens${suffix}.scss`,
+      js: `tokens${suffix}.js`,
+      ts: `tokens${suffix}.ts`,
+      json: `tokens${suffix}.json`,
+      android: `tokens${suffix}.xml`,
+      ios: `tokens${suffix}.h`
+    };
+  };
+  const generateSelector = () => {
+    if (isDefaultTheme) {
+      return selectorPattern.default;
+    }
+    return selectorPattern.others.replace("{mode}", themeName);
+  };
+  const defaultOutputFiles = generateOutputFiles();
+  return {
+    isDefault: definition?.isDefault ?? isDefaultTheme,
+    suffix: definition?.suffix ?? (isDefaultTheme ? null : `-${themeName}`),
+    selector: definition?.selector ?? generateSelector(),
+    mediaQuery: definition?.mediaQuery,
+    dataAttribute: definition?.dataAttribute,
+    outputFiles: {
+      ...defaultOutputFiles,
+      ...definition?.outputFiles
+    }
+  };
+}
+function resolveThemesConfig(config) {
+  const base = defaultThemesConfig;
+  const selectorPattern = {
+    default: config?.selectorPattern?.default ?? base.selectorPattern.default,
+    others: config?.selectorPattern?.others ?? base.selectorPattern.others
+  };
+  const defaultThemeName = config?.default?.toLowerCase() ?? base.default;
+  let definitions;
+  if (config?.definitions && Object.keys(config.definitions).length > 0) {
+    definitions = {};
+    for (const [themeName, definition] of Object.entries(config.definitions)) {
+      const normalizedName = themeName.toLowerCase();
+      const isDefaultTheme = definition.isDefault ?? normalizedName === defaultThemeName;
+      const resolvedDef = resolveThemeDefinition(
+        normalizedName,
+        definition,
+        selectorPattern,
+        defaultOutputFileNames,
+        isDefaultTheme
+      );
+      Object.defineProperty(definitions, normalizedName, {
+        value: resolvedDef,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    }
+  } else {
+    definitions = { ...defaultThemeDefinitions };
+  }
+  return {
+    enabled: config?.enabled ?? base.enabled,
+    autoDetect: config?.autoDetect ?? base.autoDetect,
+    default: defaultThemeName,
+    ignoreModes: config?.ignoreModes ?? [...base.ignoreModes],
+    selectorPattern,
+    definitions
+  };
+}
+function resolveIconsConfig(config, options) {
+  const base = defaultIconsConfig;
+  const configDir = options.configDir ?? options.cwd ?? process.cwd();
+  return {
+    sourceDir: config?.sourceDir ? path4__default.resolve(configDir, config.sourceDir) : base.sourceDir,
+    outputDir: config?.outputDir ? path4__default.resolve(configDir, config.outputDir) : base.outputDir,
+    framework: config?.framework ?? base.framework,
+    typescript: config?.typescript ?? base.typescript,
+    optimize: config?.optimize ?? base.optimize,
+    prefix: config?.prefix ?? base.prefix
+  };
+}
+function resolveTokensConfig(config, options) {
+  const base = defaultTokensConfig;
+  const configDir = options.configDir ?? options.cwd ?? process.cwd();
+  const resolveDir = (dir) => path4__default.resolve(configDir, dir);
+  const outputDirsMap = new Map(Object.entries(base.outputDirs));
+  if (config?.outputDirs) {
+    for (const [format, dir] of Object.entries(config.outputDirs)) {
+      if (dir !== void 0) {
+        outputDirsMap.set(format, resolveDir(dir));
       }
     }
-    if (preRelease !== void 0 && preRelease.length === 0) {
-      return false;
-    }
-    return true;
-  },
-  { message: "Invalid semantic version format" }
-);
-var customTransformSchema = z.object({
-  name: z.string().min(1, "Transform name is required"),
-  description: z.string().optional(),
-  type: z.enum(["value", "attribute", "name"]).optional().default("value"),
-  transform: z.function().optional(),
-  filter: z.function().optional(),
-  matcher: z.function().optional()
-});
-var customFormatSchema = z.object({
-  name: z.string().min(1, "Format name is required"),
-  description: z.string().optional(),
-  formatter: z.function().optional(),
-  extension: z.string().min(1).optional()
-});
-var outputFormatEnum = z.enum(["css", "scss", "js", "ts", "json", "android", "ios"]);
-var themeDefinitionSchema = z.object({
-  isDefault: z.boolean().optional().default(false),
-  suffix: z.string().nullable().optional(),
-  selector: z.string().min(1, "Theme selector is required"),
-  mediaQuery: z.string().optional(),
-  dataAttribute: z.string().optional(),
-  outputFiles: z.record(outputFormatEnum, z.string()).optional()
-});
-var themeSelectorPatternSchema = z.object({
-  default: z.string().optional().default(":root"),
-  others: z.string().optional().default('[data-dsai-theme="{mode}"]')
-});
-var themesConfigSchema = z.object({
-  enabled: z.boolean().optional().default(true),
-  autoDetect: z.boolean().optional().default(true),
-  default: z.string().optional().default("light"),
-  ignoreModes: z.array(z.string()).optional().default([]),
-  selectorPattern: themeSelectorPatternSchema.optional(),
-  definitions: z.record(z.string(), themeDefinitionSchema).optional(),
-  // Legacy fields (for backward compatibility)
-  defaultMode: z.enum(["light", "dark", "system"]).optional(),
-  modes: z.record(
-    z.string(),
-    z.object({
-      selector: z.string().min(1),
-      mediaQuery: z.string().optional(),
-      dataAttribute: z.string().optional(),
-      cssVariables: z.boolean().optional(),
-      generateSeparateFiles: z.boolean().optional(),
-      prefix: z.string().optional()
-    })
-  ).optional(),
-  outputFileName: z.string().optional(),
-  colorScheme: z.object({
-    light: z.string().optional(),
-    dark: z.string().optional()
-  }).optional()
-});
-var iconOptimizationSchema = z.object({
-  enabled: z.boolean().optional().default(true),
-  removeComments: z.boolean().optional().default(true),
-  removeDimensions: z.boolean().optional().default(false),
-  removeViewBox: z.boolean().optional().default(false),
-  removeXMLNS: z.boolean().optional().default(true),
-  cleanupIds: z.boolean().optional().default(true),
-  minify: z.boolean().optional().default(true)
-});
-var iconSpriteSchema = z.object({
-  enabled: z.boolean().optional().default(true),
-  fileName: z.string().optional().default("icons"),
-  format: z.enum(["symbol", "stack", "css"]).optional().default("symbol"),
-  prefix: z.string().optional().default("icon-")
-});
-var iconsConfigSchema = z.object({
-  enabled: z.boolean().optional().default(true),
-  sourceDir: z.string().optional().default("assets/icons"),
-  outputDir: z.string().optional().default("dist/icons"),
-  formats: z.array(z.enum(["svg", "react", "vue", "sprite", "font"])).optional().default(["svg"]),
-  optimization: iconOptimizationSchema.optional(),
-  sprite: iconSpriteSchema.optional(),
-  componentPrefix: z.string().optional().default("Icon"),
-  componentSuffix: z.string().optional().default(""),
-  generateIndex: z.boolean().optional().default(true),
-  generateTypes: z.boolean().optional().default(true)
-});
-var tokenBuildConfigSchema = z.object({
-  format: outputFormatSchema,
-  outputDir: z.string().optional(),
-  outputFileName: z.string().optional(),
-  fileExtension: z.string().optional(),
-  prefix: z.string().optional(),
-  useVariables: z.boolean().optional(),
-  selector: z.string().optional(),
-  transforms: z.array(z.string()).optional(),
-  customTransforms: z.array(customTransformSchema).optional(),
-  filter: z.function().optional(),
-  header: z.string().optional(),
-  footer: z.string().optional()
-});
-var postprocessConfigSchema = z.object({
-  enabled: z.boolean().optional(),
-  cssDir: z.string().optional(),
-  files: z.array(z.string()).optional(),
-  replacements: z.array(
-    z.object({
-      description: z.string().optional(),
-      from: z.union([z.string(), z.instanceof(RegExp)]),
-      to: z.string()
-    })
-  ).optional()
-});
-var scssConfigSchema = z.object({
-  /** Output styles to generate: 'expanded' (readable) or 'compressed' (minified) */
-  outputStyles: z.array(z.enum(["expanded", "compressed"])).optional(),
-  /** Generate source maps for SCSS compilation */
-  generateSourceMaps: z.boolean().optional(),
-  /** Suffix for minified files (e.g., '.min') */
-  minifiedSuffix: z.string().optional(),
-  /** Theme entry point SCSS file */
-  themeEntry: z.string().optional(),
-  /** Utilities entry point SCSS file */
-  utilitiesEntry: z.string().optional(),
-  /** Output directory for compiled CSS files */
-  cssOutputDir: z.string().optional(),
-  /** Additional Sass load paths */
-  loadPaths: z.array(z.string()).optional(),
-  /** Target CSS framework for variable name mapping */
-  framework: z.enum(["bootstrap", "tailwind", "material", "custom"]).optional(),
-  /** Custom token to variable name mappings */
-  nameMapping: z.record(z.string(), z.string()).optional(),
-  /** Output path for Bootstrap-compatible SCSS variables */
-  variablesOutput: z.string().optional()
-});
-var tokenCacheConfigSchema = z.object({
-  enabled: z.boolean().optional().default(true),
-  directory: z.string().optional().default(".cache"),
-  hashType: hashTypeSchema.optional().default("content"),
-  maxAge: z.number().optional().default(864e5)
-});
-var tokenWatchConfigSchema = z.object({
-  enabled: z.boolean().optional().default(false),
-  debounce: z.number().optional().default(300),
-  clearScreen: z.boolean().optional().default(true),
-  ignorePatterns: z.array(z.string()).optional().default([])
-});
-var tokensHooksSchema = z.object({
-  onBuildStart: z.function().optional(),
-  onFormatComplete: z.function().optional(),
-  onAllFormatsComplete: z.function().optional(),
-  onBuildComplete: z.function().optional(),
-  onError: z.function().optional()
-});
-var buildPipelineStepSchema = z.enum([
-  "validate",
-  "snapshot",
-  "preprocess",
-  "transform",
-  "style-dictionary",
-  "sync",
-  "sass-theme",
-  "sass-theme-minified",
-  "postprocess",
-  "sass-utilities",
-  "sass-utilities-minified",
-  "bundle"
-]);
-var tokensBuildPipelineSchema = z.object({
-  /**
-   * Steps to include in the build.
-   * Order matters - steps run in sequence.
-   * Default includes all steps for full @dsai-io/tokens build.
-   * Simpler packages can use subset like ['validate', 'transform', 'style-dictionary']
-   */
-  steps: z.array(buildPipelineStepSchema).optional(),
-  /**
-   * Paths configuration for build steps
-   */
-  paths: z.object({
-    /** Source file for sync step (Style Dictionary JS output) */
-    syncSource: z.string().optional(),
-    /** Target file for sync step */
-    syncTarget: z.string().optional(),
-    /** SCSS theme input file */
-    sassThemeInput: z.string().optional(),
-    /** CSS theme output file */
-    sassThemeOutput: z.string().optional(),
-    /** CSS theme minified output file */
-    sassThemeMinifiedOutput: z.string().optional(),
-    /** SCSS utilities input file */
-    sassUtilitiesInput: z.string().optional(),
-    /** CSS utilities output file */
-    sassUtilitiesOutput: z.string().optional(),
-    /** CSS utilities minified output file */
-    sassUtilitiesMinifiedOutput: z.string().optional()
-  }).optional(),
-  /** Style Dictionary config file name */
-  styleDictionaryConfig: z.string().optional()
-});
-var tokensConfigSchema = z.object({
-  enabled: z.boolean().optional().default(true),
-  sourcePatterns: z.array(z.string()).optional().default(["src/tokens/**/*.json", "src/tokens/**/*.yaml"]),
-  outputDirs: z.object({
-    css: z.string().optional().default("dist/css"),
-    scss: z.string().optional().default("dist/scss"),
-    less: z.string().optional().default("dist/less"),
-    js: z.string().optional().default("dist/js"),
-    ts: z.string().optional().default("dist/ts"),
-    json: z.string().optional().default("dist/json")
-  }).optional(),
-  additionalScssDirectories: z.array(z.string()).optional().default([]),
-  outputFileNames: z.object({
-    variables: z.string().optional().default("variables"),
-    utilities: z.string().optional().default("utilities"),
-    mixins: z.string().optional().default("mixins"),
-    tokens: z.string().optional().default("tokens")
-  }).optional(),
-  prefix: z.string().optional().default("dsai"),
-  mergeOrder: z.array(z.string()).optional().default(["base", "semantic", "component"]),
-  createBundle: z.boolean().optional().default(true),
-  bundleFileName: z.string().optional().default("bundle"),
-  formats: z.array(outputFormatSchema).optional().default(["css", "scss", "json"]),
-  platforms: z.record(z.string(), tokenBuildConfigSchema).optional(),
-  transforms: z.array(z.string()).optional().default([]),
-  customTransforms: z.array(customTransformSchema).optional().default([]),
-  customFormats: z.array(customFormatSchema).optional().default([]),
-  hooks: tokensHooksSchema.optional(),
-  cache: tokenCacheConfigSchema.optional(),
-  watch: tokenWatchConfigSchema.optional(),
-  verbose: z.boolean().optional().default(false),
-  /** SCSS/CSS output configuration */
-  scss: scssConfigSchema.optional(),
-  /** Build pipeline configuration */
-  pipeline: tokensBuildPipelineSchema.optional(),
-  /** Postprocess configuration */
-  postprocess: postprocessConfigSchema.optional()
-});
-var buildConfigSchema = z.object({
-  outDir: z.string().optional().default("dist"),
-  clean: z.boolean().optional().default(true),
-  sourcemap: z.boolean().optional().default(false),
-  minify: z.boolean().optional().default(true),
-  parallel: z.boolean().optional().default(true),
-  maxConcurrency: z.number().optional().default(4)
-});
-var globalConfigSchema = z.object({
-  logLevel: logLevelSchema.optional().default("info"),
-  colors: z.boolean().optional().default(true),
-  ci: z.boolean().optional().default(false),
-  dryRun: z.boolean().optional().default(false),
-  cwd: z.string().optional(),
-  configPath: z.string().optional(),
-  framework: frameworkSchema.optional(),
-  build: buildConfigSchema.optional()
-});
-z.object({
-  $schema: z.string().optional(),
-  extends: z.union([z.string(), z.array(z.string())]).optional(),
-  global: globalConfigSchema.optional(),
-  tokens: tokensConfigSchema.optional(),
-  themes: themesConfigSchema.optional(),
-  icons: iconsConfigSchema.optional()
-});
-
-// src/config/defaults.ts
-var DEFAULT_PREFIX = "--dsai-";
-var DEFAULT_LOG_LEVEL = "info";
-var DEFAULT_OUTPUT_DIR = "dist";
-var DEFAULT_SOURCE_DIR = "figma-exports";
-var DEFAULT_COLLECTIONS_DIR = "collections";
-var DEFAULT_ICONS_SOURCE_DIR = "icons";
-var DEFAULT_ICONS_OUTPUT_DIR = "dist/icons";
-var defaultSourcePatterns = ["theme.json", "tokens.json", "*.tokens.json"];
-var defaultFormats = ["css", "scss", "js", "ts", "json"];
-var defaultOutputFileNames = {
-  css: "tokens.css",
-  scss: "_tokens.scss",
-  js: "tokens.js",
-  ts: "tokens.ts",
-  json: "tokens.json",
-  android: "tokens.xml",
-  ios: "tokens.h"
-};
-var defaultSelectorPattern = {
-  default: ":root",
-  others: '[data-dsai-theme="{mode}"]'
-};
-var defaultThemeDefinitions = {
-  light: {
-    isDefault: true,
-    suffix: null,
-    selector: ":root",
-    outputFiles: {
-      css: "tokens.css",
-      scss: "_tokens.scss",
-      js: "tokens.js",
-      ts: "tokens.ts",
-      json: "tokens.json",
-      android: "tokens.xml",
-      ios: "tokens.h"
-    }
-  },
-  dark: {
-    isDefault: false,
-    suffix: "-dark",
-    selector: '[data-dsai-theme="dark"]',
-    mediaQuery: "(prefers-color-scheme: dark)",
-    outputFiles: {
-      css: "tokens-dark.css",
-      scss: "_tokens-dark.scss",
-      js: "tokens-dark.js",
-      ts: "tokens-dark.ts",
-      json: "tokens-dark.json",
-      android: "tokens-dark.xml",
-      ios: "tokens-dark.h"
-    }
-  }
-};
-var defaultThemesConfig = {
-  enabled: true,
-  autoDetect: true,
-  default: "light",
-  ignoreModes: [],
-  selectorPattern: defaultSelectorPattern};
-var defaultIconFramework = "react";
-var defaultIconsConfig = {
-  sourceDir: DEFAULT_ICONS_SOURCE_DIR,
-  outputDir: DEFAULT_ICONS_OUTPUT_DIR,
-  framework: defaultIconFramework,
-  typescript: true,
-  optimize: true,
-  prefix: "Icon"
-};
-var defaultTokensConfig = {
-  source: "theme",
-  sourceDir: DEFAULT_SOURCE_DIR,
-  collectionsDir: DEFAULT_COLLECTIONS_DIR,
-  sourcePatterns: defaultSourcePatterns,
-  outputDir: DEFAULT_OUTPUT_DIR,
-  outputDirs: {},
-  outputFileNames: defaultOutputFileNames,
-  prefix: DEFAULT_PREFIX,
-  formats: defaultFormats,
-  mergeOrder: "after",
-  createBundle: false,
-  outputReferences: true,
-  baseFontSize: 16,
-  separateThemeFiles: false,
-  watch: false};
-var defaultGlobalConfig = {
-  cwd: process.cwd(),
-  debug: false,
-  logLevel: DEFAULT_LOG_LEVEL
-};
-({
-  configDir: process.cwd()
-});
-function resolveGlobalConfig(config, options) {
-  const base = defaultGlobalConfig;
-  const cwd = options.cwd ?? process.cwd();
-  return {
-    cwd: config?.cwd ? path4__default.resolve(cwd, config.cwd) : cwd,
-    debug: config?.debug ?? base.debug,
-    logLevel: config?.logLevel ?? base.logLevel
-  };
-}
-function resolveThemeDefinition(themeName, definition, selectorPattern, _outputFileNames, isDefaultTheme) {
-  const generateOutputFiles = () => {
-    const suffix = isDefaultTheme ? "" : `-${themeName}`;
-    return {
-      css: `tokens${suffix}.css`,
-      scss: `_tokens${suffix}.scss`,
-      js: `tokens${suffix}.js`,
-      ts: `tokens${suffix}.ts`,
-      json: `tokens${suffix}.json`,
-      android: `tokens${suffix}.xml`,
-      ios: `tokens${suffix}.h`
-    };
-  };
-  const generateSelector = () => {
-    if (isDefaultTheme) {
-      return selectorPattern.default;
-    }
-    return selectorPattern.others.replace("{mode}", themeName);
-  };
-  const defaultOutputFiles = generateOutputFiles();
-  return {
-    isDefault: definition?.isDefault ?? isDefaultTheme,
-    suffix: definition?.suffix ?? (isDefaultTheme ? null : `-${themeName}`),
-    selector: definition?.selector ?? generateSelector(),
-    mediaQuery: definition?.mediaQuery,
-    dataAttribute: definition?.dataAttribute,
-    outputFiles: {
-      ...defaultOutputFiles,
-      ...definition?.outputFiles
-    }
-  };
-}
-function resolveThemesConfig(config) {
-  const base = defaultThemesConfig;
-  const selectorPattern = {
-    default: config?.selectorPattern?.default ?? base.selectorPattern.default,
-    others: config?.selectorPattern?.others ?? base.selectorPattern.others
-  };
-  const defaultThemeName = config?.default?.toLowerCase() ?? base.default;
-  let definitions;
-  if (config?.definitions && Object.keys(config.definitions).length > 0) {
-    definitions = {};
-    for (const [themeName, definition] of Object.entries(config.definitions)) {
-      const normalizedName = themeName.toLowerCase();
-      const isDefaultTheme = definition.isDefault ?? normalizedName === defaultThemeName;
-      const resolvedDef = resolveThemeDefinition(
-        normalizedName,
-        definition,
-        selectorPattern,
-        defaultOutputFileNames,
-        isDefaultTheme
-      );
-      Object.defineProperty(definitions, normalizedName, {
-        value: resolvedDef,
-        writable: true,
-        enumerable: true,
-        configurable: true
-      });
-    }
-  } else {
-    definitions = { ...defaultThemeDefinitions };
-  }
-  return {
-    enabled: config?.enabled ?? base.enabled,
-    autoDetect: config?.autoDetect ?? base.autoDetect,
-    default: defaultThemeName,
-    ignoreModes: config?.ignoreModes ?? [...base.ignoreModes],
-    selectorPattern,
-    definitions
-  };
-}
-function resolveIconsConfig(config, options) {
-  const base = defaultIconsConfig;
-  const configDir = options.configDir ?? options.cwd ?? process.cwd();
-  return {
-    sourceDir: config?.sourceDir ? path4__default.resolve(configDir, config.sourceDir) : base.sourceDir,
-    outputDir: config?.outputDir ? path4__default.resolve(configDir, config.outputDir) : base.outputDir,
-    framework: config?.framework ?? base.framework,
-    typescript: config?.typescript ?? base.typescript,
-    optimize: config?.optimize ?? base.optimize,
-    prefix: config?.prefix ?? base.prefix
-  };
-}
-function resolveTokensConfig(config, options) {
-  const base = defaultTokensConfig;
-  const configDir = options.configDir ?? options.cwd ?? process.cwd();
-  const resolveDir = (dir) => path4__default.resolve(configDir, dir);
-  const outputDirsMap = new Map(Object.entries(base.outputDirs));
-  if (config?.outputDirs) {
-    for (const [format, dir] of Object.entries(config.outputDirs)) {
-      if (dir !== void 0) {
-        outputDirsMap.set(format, resolveDir(dir));
-      }
-    }
-  }
-  const outputDirs = Object.fromEntries(outputDirsMap);
-  const collectionMappingMap = /* @__PURE__ */ new Map();
-  if (config?.collectionMapping) {
-    for (const [name, filePath] of Object.entries(config.collectionMapping)) {
-      collectionMappingMap.set(name, resolveDir(filePath));
+  }
+  const outputDirs = Object.fromEntries(outputDirsMap);
+  const collectionMappingMap = /* @__PURE__ */ new Map();
+  if (config?.collectionMapping) {
+    for (const [name, filePath] of Object.entries(config.collectionMapping)) {
+      collectionMappingMap.set(name, resolveDir(filePath));
     }
   }
   const collectionMapping = Object.fromEntries(collectionMappingMap);
@@ -8406,10 +8138,32 @@ function resolveTokensConfig(config, options) {
     postprocess: config?.postprocess
   };
 }
+function resolveAliasesConfig(config) {
+  const base = defaultAliasesConfig;
+  return {
+    importAlias: config?.importAlias ?? base.importAlias,
+    ui: config?.ui ?? base.ui,
+    hooks: config?.hooks ?? base.hooks,
+    utils: config?.utils ?? base.utils,
+    components: config?.components ?? base.components,
+    lib: config?.lib ?? base.lib
+  };
+}
+function resolveComponentsConfig(config) {
+  const base = defaultComponentsConfig;
+  return {
+    enabled: config?.enabled ?? base.enabled,
+    registryUrl: config?.registryUrl ?? base.registryUrl,
+    tsx: config?.tsx ?? base.tsx,
+    overwrite: config?.overwrite ?? base.overwrite
+  };
+}
 function applyOverrides(config, overrides) {
   return {
     tokens: overrides.tokens ? { ...config.tokens, ...overrides.tokens } : config.tokens,
     icons: overrides.icons ? { ...config.icons, ...overrides.icons } : config.icons,
+    aliases: overrides.aliases ? { ...config.aliases, ...overrides.aliases } : config.aliases,
+    components: overrides.components ? { ...config.components, ...overrides.components } : config.components,
     global: overrides.global ? { ...config.global, ...overrides.global } : config.global
   };
 }
@@ -8420,6 +8174,8 @@ function resolveConfig(config = {}, options = {}) {
     global: resolveGlobalConfig(mergedConfig.global, options),
     tokens: resolveTokensConfig(mergedConfig.tokens, options),
     icons: resolveIconsConfig(mergedConfig.icons, options),
+    aliases: resolveAliasesConfig(mergedConfig.aliases),
+    components: resolveComponentsConfig(mergedConfig.components),
     configDir
   };
 }
@@ -8484,10 +8240,215 @@ async function loadConfig(options = {}) {
     warnings
   };
 }
+function loadItem(name, registryDir) {
+  const subdirs = ["components", "hooks", "utils", "lib", "styles", "types"];
+  for (const sub of subdirs) {
+    const filePath = join(registryDir, sub, `${name}.json`);
+    if (existsSync(filePath)) {
+      return JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+  }
+  return null;
+}
+function resolveTree(names, registryDir) {
+  const visited = /* @__PURE__ */ new Map();
+  const queue = [...names];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    if (visited.has(name)) continue;
+    const item = loadItem(name, registryDir);
+    if (!item) {
+      throw new Error(`Registry item "${name}" not found. Run \`dsai registry build\` or check the name.`);
+    }
+    visited.set(name, item);
+    for (const dep of item.registryDependencies) {
+      if (!visited.has(dep)) queue.push(dep);
+    }
+  }
+  const inDeg = /* @__PURE__ */ new Map();
+  for (const [name, item] of visited) {
+    inDeg.set(name, item.registryDependencies.filter((d3) => visited.has(d3)).length);
+  }
+  const sorted = [];
+  const ready = [];
+  for (const [name, deg] of inDeg) {
+    if (deg === 0) ready.push(name);
+  }
+  while (ready.length > 0) {
+    const name = ready.shift();
+    sorted.push(visited.get(name));
+    for (const [otherName, otherItem] of visited) {
+      if (otherItem.registryDependencies.includes(name)) {
+        const newDeg = (inDeg.get(otherName) ?? 1) - 1;
+        inDeg.set(otherName, newDeg);
+        if (newDeg === 0) ready.push(otherName);
+      }
+    }
+  }
+  if (sorted.length !== visited.size) {
+    const missing = [...visited.keys()].filter((n) => !sorted.some((s) => s.name === n));
+    throw new Error(`Circular dependency detected involving: ${missing.join(", ")}`);
+  }
+  const allDeps = /* @__PURE__ */ new Set();
+  const allDevDeps = /* @__PURE__ */ new Set();
+  const lightVars = {};
+  const darkVars = {};
+  for (const item of sorted) {
+    for (const dep of item.dependencies) allDeps.add(dep);
+    for (const dep of item.devDependencies) allDevDeps.add(dep);
+    if (item.cssVars?.light) Object.assign(lightVars, item.cssVars.light);
+    if (item.cssVars?.dark) Object.assign(darkVars, item.cssVars.dark);
+  }
+  return {
+    items: sorted,
+    dependencies: [...allDeps],
+    devDependencies: [...allDevDeps],
+    cssVars: { light: lightVars, dark: darkVars }
+  };
+}
 
-// src/cli/commands/tokens.ts
-init_tokens();
-init_snapshot();
+// src/registry/transformer.ts
+function transformImports(content, options) {
+  const { aliases } = options;
+  let result = content;
+  result = result.replace(
+    /(from\s+['"])(?:\.\.\/)+types(?:\/([^'"]+))?(['"])/g,
+    (_match, prefix, subpath, suffix) => {
+      if (subpath) {
+        return `${prefix}${aliases.importAlias}${aliases.components}/types/${subpath}${suffix}`;
+      }
+      return `${prefix}${aliases.importAlias}${aliases.components}/types${suffix}`;
+    }
+  );
+  result = result.replace(
+    /(from\s+['"])\.\.\/(([A-Z]\w+)(\/[^'"]+)?)(['"])/g,
+    (_match, prefix, _fullPath, dirName, subPath, suffix) => {
+      const kebab = dirName.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+      if (subPath) {
+        return `${prefix}${aliases.importAlias}${aliases.ui}/${kebab}${subPath}${suffix}`;
+      }
+      return `${prefix}${aliases.importAlias}${aliases.ui}/${kebab}${suffix}`;
+    }
+  );
+  result = result.replace(
+    /(from\s+['"])(?:\.\.\/)+hooks\/(\w+)(['"])/g,
+    `$1${aliases.importAlias}${aliases.hooks}/$2$3`
+  );
+  result = result.replace(
+    /(from\s+['"])(?:\.\.\/)+utils\/(\w+(?:\/\w+)?)(['"])/g,
+    `$1${aliases.importAlias}${aliases.utils}/$2$3`
+  );
+  result = result.replace(
+    /(from\s+['"])(?:\.\.\/)+utils(['"])/g,
+    `$1${aliases.importAlias}${aliases.utils}$2`
+  );
+  return result;
+}
+function normalizeExtensions(content, tsx) {
+  if (!tsx) {
+    return content.replace(/(from\s+['"][^'"]+)\.tsx(['"])/g, "$1.jsx$2").replace(/(from\s+['"][^'"]+)\.ts(['"])/g, "$1.js$2");
+  }
+  return content;
+}
+
+// src/registry/writer.ts
+function getTargetDir(type, aliases) {
+  switch (type) {
+    case "registry:ui":
+      return aliases.ui;
+    case "registry:hook":
+      return aliases.hooks;
+    case "registry:util":
+      return aliases.utils;
+    case "registry:lib":
+      return aliases.lib;
+    case "registry:component":
+      return aliases.components;
+    case "registry:type":
+      return aliases.components;
+    case "registry:style":
+      return aliases.ui;
+    default:
+      return aliases.lib;
+  }
+}
+function detectPackageManager(projectDir) {
+  if (existsSync(join(projectDir, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(projectDir, "bun.lockb")) || existsSync(join(projectDir, "bun.lock"))) return "bun";
+  if (existsSync(join(projectDir, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function getInstallArgs(pm, packages, dev) {
+  switch (pm) {
+    case "pnpm":
+      return ["pnpm", ["add", ...[], ...packages]];
+    case "yarn":
+      return ["yarn", ["add", ...[], ...packages]];
+    case "bun":
+      return ["bun", ["add", ...[], ...packages]];
+    default:
+      return ["npm", ["install", ...[], ...packages]];
+  }
+}
+function writeRegistryItems(tree, options) {
+  const { projectDir, aliases, components, overwrite, dryRun, log } = options;
+  const result = { written: [], skipped: [], installedDeps: [] };
+  const shouldOverwrite = overwrite ?? components.overwrite;
+  for (const item of tree.items) {
+    const targetBaseDir = getTargetDir(item.type, aliases);
+    for (const file of item.files) {
+      const fileName = basename(file.path);
+      let targetPath;
+      if (file.target) {
+        targetPath = join(projectDir, file.target);
+      } else if (item.type === "registry:ui" || item.type === "registry:component") {
+        targetPath = join(projectDir, targetBaseDir, item.name, fileName);
+      } else if (item.type === "registry:type") {
+        targetPath = join(projectDir, targetBaseDir, file.path);
+      } else {
+        targetPath = join(projectDir, targetBaseDir, fileName);
+      }
+      if (existsSync(targetPath) && !shouldOverwrite) {
+        if (log) log(`  Skipped (exists): ${targetPath}`);
+        result.skipped.push(targetPath);
+        continue;
+      }
+      let content = file.content;
+      content = transformImports(content, { aliases, tsx: components.tsx });
+      content = normalizeExtensions(content, components.tsx);
+      if (dryRun) {
+        if (log) log(`  Would write: ${targetPath}`);
+        result.written.push(targetPath);
+        continue;
+      }
+      const dir = dirname(targetPath);
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+      writeFileSync(targetPath, content, "utf-8");
+      if (log) log(`  Written: ${targetPath}`);
+      result.written.push(targetPath);
+    }
+  }
+  const depsToInstall = tree.dependencies.filter((dep) => {
+    const pkgJsonPath = join(projectDir, "package.json");
+    if (existsSync(pkgJsonPath)) {
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      const allDeps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+      return !Reflect.get(allDeps, dep);
+    }
+    return true;
+  });
+  if (depsToInstall.length > 0 && !dryRun) {
+    const pm = detectPackageManager(projectDir);
+    const [cmd, args] = getInstallArgs(pm, depsToInstall);
+    if (log) log(`  Installing: ${cmd} ${args.join(" ")}`);
+    execFileSync(cmd, args, { cwd: projectDir, stdio: "inherit" });
+    result.installedDeps = depsToInstall;
+  } else if (depsToInstall.length > 0 && dryRun) {
+    if (log) log(`  Would install: ${depsToInstall.join(", ")}`);
+    result.installedDeps = depsToInstall;
+  }
+  return result;
+}
 
 // src/cli/types.ts
 var ExitCode = {
@@ -8705,48 +8666,531 @@ function createLogger(options = {}) {
         console.log(`${prefixStr}${colors_default.muted("DEBUG")} ${colors_default.dim(message)}`);
       }
     }
-  };
-}
-function formatDuration(ms) {
-  if (ms < 1e3) {
-    return `${ms}ms`;
-  }
-  if (ms < 6e4) {
-    return `${(ms / 1e3).toFixed(2)}s`;
-  }
-  const minutes = Math.floor(ms / 6e4);
-  const seconds = (ms % 6e4 / 1e3).toFixed(0);
-  return `${minutes}m ${seconds}s`;
-}
-function formatBytes(bytes) {
-  if (bytes === 0) {
-    return "0 B";
-  }
-  const k3 = 1024;
-  const i = Math.floor(Math.log(bytes) / Math.log(k3));
-  const sizeIndex = Math.min(i, 3);
-  let sizeLabel;
-  switch (sizeIndex) {
-    case 0:
-      sizeLabel = "B";
-      break;
-    case 1:
-      sizeLabel = "KB";
-      break;
-    case 2:
-      sizeLabel = "MB";
-      break;
-    default:
-      sizeLabel = "GB";
-  }
-  return `${Number.parseFloat((bytes / k3 ** sizeIndex).toFixed(2))} ${sizeLabel}`;
-}
-function formatCount(count, singular, plural) {
-  const label = count === 1 ? singular : plural ?? `${singular}s`;
-  return `${count} ${label}`;
+  };
+}
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(2)}s`;
+  }
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = (ms % 6e4 / 1e3).toFixed(0);
+  return `${minutes}m ${seconds}s`;
+}
+function formatBytes(bytes) {
+  if (bytes === 0) {
+    return "0 B";
+  }
+  const k3 = 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k3));
+  const sizeIndex = Math.min(i, 3);
+  let sizeLabel;
+  switch (sizeIndex) {
+    case 0:
+      sizeLabel = "B";
+      break;
+    case 1:
+      sizeLabel = "KB";
+      break;
+    case 2:
+      sizeLabel = "MB";
+      break;
+    default:
+      sizeLabel = "GB";
+  }
+  return `${Number.parseFloat((bytes / k3 ** sizeIndex).toFixed(2))} ${sizeLabel}`;
+}
+function formatCount(count, singular, plural) {
+  const label = count === 1 ? singular : plural ?? `${singular}s`;
+  return `${count} ${label}`;
+}
+
+// src/cli/commands/add.ts
+var VALID_TYPES = ["ui", "hook", "util", "lib", "type", "style"];
+function createAddCommand() {
+  const cmd = new Command("add").description("Add DSAi items (components, hooks, utils) to your project").argument("[items...]", "Item names to add (e.g., button use-focus-trap cn)").option("--all", "Add all items of the specified type (default: ui)", false).option("--type <type>", "Filter by type: ui, hook, util, lib, type").option("--overwrite", "Overwrite existing files", false).option("--dry-run", "Preview changes without writing files", false).option("--registry <path>", "Path to local registry directory").option("--list", "List all available items", false).action(async (items, opts, cmdObj) => {
+    const parentOpts = cmdObj.parent?.opts() ?? {};
+    const allOpts = {
+      ...parentOpts,
+      ...opts,
+      dryRun: opts.dryRun || parentOpts.dryRun,
+      overwrite: opts.overwrite || parentOpts.overwrite
+    };
+    const logger = createLogger(allOpts);
+    try {
+      const { config } = await loadConfig({
+        cwd: allOpts.cwd ?? process.cwd(),
+        configPath: allOpts.config
+      });
+      const registryDir = allOpts.registry ? resolve(allOpts.registry) : join(config.configDir, "node_modules", "@dsai-io", "tools", "registry");
+      if (!existsSync(registryDir)) {
+        logger.error(
+          `Registry not found at: ${registryDir}
+Run \`dsai registry build\` or use --registry <path>.`
+        );
+        process.exit(ExitCode.GeneralError);
+      }
+      const typeFilter = allOpts.type;
+      if (typeFilter && !VALID_TYPES.includes(typeFilter)) {
+        logger.error(
+          `Invalid type "${typeFilter}". Valid types: ${VALID_TYPES.join(", ")}`
+        );
+        process.exit(ExitCode.GeneralError);
+      }
+      const filterByType = (entries) => {
+        if (!typeFilter) return entries;
+        return entries.filter((i) => i.type === `registry:${typeFilter}`);
+      };
+      if (allOpts.list) {
+        const indexPath = join(registryDir, "index.json");
+        if (!existsSync(indexPath)) {
+          logger.error("Registry index not found.");
+          process.exit(ExitCode.GeneralError);
+        }
+        const index = JSON.parse(readFileSync(indexPath, "utf-8"));
+        const filtered = filterByType(index.items);
+        console.log(`
+${colors.bold("Available items:")}
+`);
+        const grouped = {};
+        for (const item of filtered) {
+          const type = item.type.replace("registry:", "");
+          if (!grouped[type]) grouped[type] = [];
+          grouped[type].push(item);
+        }
+        const displayOrder = ["ui", "hook", "util", "lib", "type", "style"];
+        for (const type of displayOrder) {
+          const typeItems = grouped[type];
+          if (!typeItems || typeItems.length === 0) continue;
+          console.log(`  ${colors.cyan(type)} (${typeItems.length}):`);
+          for (const item of typeItems.sort((a, b3) => a.name.localeCompare(b3.name))) {
+            console.log(
+              `    ${colors.bold(item.name.padEnd(28))} ${colors.muted(item.description)}`
+            );
+          }
+          console.log();
+        }
+        console.log(`  ${colors.muted(`${filtered.length} items available`)}
+`);
+        console.log(`${colors.muted("Usage:")}`);
+        console.log(`  ${colors.command("dsai add button modal")}         ${colors.muted("Add specific items")}`);
+        console.log(`  ${colors.command("dsai add use-focus-trap cn")}    ${colors.muted("Add hooks and utils")}`);
+        console.log(`  ${colors.command("dsai add --all")}                ${colors.muted("Add all UI components")}`);
+        console.log(`  ${colors.command("dsai add --all --type hook")}    ${colors.muted("Add all hooks")}`);
+        console.log(`  ${colors.command("dsai add --list --type util")}   ${colors.muted("List only utilities")}
+`);
+        return;
+      }
+      if (!allOpts.all && items.length === 0) {
+        logger.error(
+          `No items specified.
+Usage: ${colors.command("dsai add <item...>")}
+       ${colors.command("dsai add --all [--type hook|util]")}
+       ${colors.command("dsai add --list")}`
+        );
+        process.exit(ExitCode.GeneralError);
+      }
+      let itemNames = items;
+      if (allOpts.all) {
+        const indexPath = join(registryDir, "index.json");
+        const index = JSON.parse(readFileSync(indexPath, "utf-8"));
+        const effectiveType = typeFilter ?? "ui";
+        itemNames = index.items.filter((i) => i.type === `registry:${effectiveType}`).map((i) => i.name);
+        if (itemNames.length === 0) {
+          logger.error(`No items found for type "${effectiveType}".`);
+          process.exit(ExitCode.GeneralError);
+        }
+      }
+      const spinner = createSpinner();
+      spinner.start("Resolving dependencies...");
+      let tree;
+      try {
+        tree = resolveTree(itemNames, registryDir);
+      } catch (err) {
+        spinner.fail("Failed to resolve dependencies");
+        logger.error(err.message);
+        process.exit(ExitCode.GeneralError);
+      }
+      spinner.succeed(
+        `Resolved ${tree.items.length} items (${itemNames.length} requested + ${tree.items.length - itemNames.length} dependencies)`
+      );
+      console.log(`
+${colors.bold("Items to install:")}`);
+      for (const item of tree.items) {
+        const type = item.type.replace("registry:", "");
+        console.log(`  ${colors.cyan(type.padEnd(10))} ${item.name}`);
+      }
+      if (tree.dependencies.length > 0) {
+        console.log(
+          `
+${colors.bold("npm dependencies:")} ${tree.dependencies.join(", ")}`
+        );
+      }
+      console.log();
+      const writeLabel = allOpts.dryRun ? "Previewing changes..." : "Installing items...";
+      const writeSpinner = createSpinner();
+      writeSpinner.start(writeLabel);
+      const result = writeRegistryItems(tree, {
+        projectDir: config.global.cwd,
+        aliases: config.aliases,
+        components: config.components,
+        overwrite: allOpts.overwrite,
+        dryRun: allOpts.dryRun,
+        log: (msg) => {
+          writeSpinner.stop();
+          console.log(msg);
+          writeSpinner.start(writeLabel);
+        }
+      });
+      writeSpinner.succeed(
+        allOpts.dryRun ? "Dry run complete" : `Installed ${result.written.length} files`
+      );
+      if (result.skipped.length > 0) {
+        console.log(
+          `
+${colors.warning(`${result.skipped.length} files skipped (already exist). Use --overwrite to replace.`)}`
+        );
+      }
+      if (!allOpts.dryRun) {
+        console.log(`
+${colors.success("Done!")} Items are ready to use.
+`);
+        const firstItem = tree.items.find((i) => itemNames.includes(i.name)) ?? tree.items[0];
+        if (firstItem) {
+          const type = firstItem.type.replace("registry:", "");
+          const name = firstItem.name;
+          const titleCase = name.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+          console.log(`${colors.muted("Import example:")}`);
+          if (type === "ui" || type === "component") {
+            console.log(
+              `  ${colors.cyan(`import { ${titleCase} } from '${config.aliases.importAlias}${config.aliases.ui}/${name}';`)}`
+            );
+          } else if (type === "hook") {
+            console.log(
+              `  ${colors.cyan(`import { ${titleCase.replace("Use", "use")} } from '${config.aliases.importAlias}${config.aliases.hooks}/${titleCase.replace("Use", "use")}';`)}`
+            );
+          } else if (type === "util") {
+            console.log(
+              `  ${colors.cyan(`import { ${name} } from '${config.aliases.importAlias}${config.aliases.utils}/${name}';`)}`
+            );
+          }
+          console.log();
+        }
+      }
+    } catch (err) {
+      logger.error(`Unexpected error: ${err.message}`);
+      process.exit(ExitCode.GeneralError);
+    }
+  });
+  return cmd;
 }
+var logLevelSchema = z.enum(["silent", "error", "warn", "info", "debug", "verbose"]);
+var outputFormatSchema = z.enum(["css", "scss", "less", "json", "js", "ts", "esm", "cjs"]);
+var frameworkSchema = z.enum(["react", "vue", "angular", "svelte", "vanilla"]);
+var hashTypeSchema = z.enum(["content", "timestamp", "version", "none"]);
+z.string().min(1, "Glob pattern cannot be empty");
+z.string().min(1, "File path cannot be empty");
+z.string().refine(
+  (val) => {
+    const parts = val.split("-");
+    const version2 = parts[0] ?? "";
+    const preRelease = parts[1];
+    const versionParts = version2.split(".");
+    if (versionParts.length !== 3) {
+      return false;
+    }
+    for (const part of versionParts) {
+      const num = Number(part);
+      if (!Number.isInteger(num) || num < 0) {
+        return false;
+      }
+    }
+    if (preRelease !== void 0 && preRelease.length === 0) {
+      return false;
+    }
+    return true;
+  },
+  { message: "Invalid semantic version format" }
+);
+var customTransformSchema = z.object({
+  name: z.string().min(1, "Transform name is required"),
+  description: z.string().optional(),
+  type: z.enum(["value", "attribute", "name"]).optional().default("value"),
+  transform: z.function().optional(),
+  filter: z.function().optional(),
+  matcher: z.function().optional()
+});
+var customFormatSchema = z.object({
+  name: z.string().min(1, "Format name is required"),
+  description: z.string().optional(),
+  formatter: z.function().optional(),
+  extension: z.string().min(1).optional()
+});
+var outputFormatEnum = z.enum(["css", "scss", "js", "ts", "json", "android", "ios"]);
+var themeDefinitionSchema = z.object({
+  isDefault: z.boolean().optional().default(false),
+  suffix: z.string().nullable().optional(),
+  selector: z.string().min(1, "Theme selector is required"),
+  mediaQuery: z.string().optional(),
+  dataAttribute: z.string().optional(),
+  outputFiles: z.record(outputFormatEnum, z.string()).optional()
+});
+var themeSelectorPatternSchema = z.object({
+  default: z.string().optional().default(":root"),
+  others: z.string().optional().default('[data-dsai-theme="{mode}"]')
+});
+var themesConfigSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  autoDetect: z.boolean().optional().default(true),
+  default: z.string().optional().default("light"),
+  ignoreModes: z.array(z.string()).optional().default([]),
+  selectorPattern: themeSelectorPatternSchema.optional(),
+  definitions: z.record(z.string(), themeDefinitionSchema).optional(),
+  // Legacy fields (for backward compatibility)
+  defaultMode: z.enum(["light", "dark", "system"]).optional(),
+  modes: z.record(
+    z.string(),
+    z.object({
+      selector: z.string().min(1),
+      mediaQuery: z.string().optional(),
+      dataAttribute: z.string().optional(),
+      cssVariables: z.boolean().optional(),
+      generateSeparateFiles: z.boolean().optional(),
+      prefix: z.string().optional()
+    })
+  ).optional(),
+  outputFileName: z.string().optional(),
+  colorScheme: z.object({
+    light: z.string().optional(),
+    dark: z.string().optional()
+  }).optional()
+});
+var iconOptimizationSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  removeComments: z.boolean().optional().default(true),
+  removeDimensions: z.boolean().optional().default(false),
+  removeViewBox: z.boolean().optional().default(false),
+  removeXMLNS: z.boolean().optional().default(true),
+  cleanupIds: z.boolean().optional().default(true),
+  minify: z.boolean().optional().default(true)
+});
+var iconSpriteSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  fileName: z.string().optional().default("icons"),
+  format: z.enum(["symbol", "stack", "css"]).optional().default("symbol"),
+  prefix: z.string().optional().default("icon-")
+});
+var iconsConfigSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  sourceDir: z.string().optional().default("assets/icons"),
+  outputDir: z.string().optional().default("dist/icons"),
+  formats: z.array(z.enum(["svg", "react", "vue", "sprite", "font"])).optional().default(["svg"]),
+  optimization: iconOptimizationSchema.optional(),
+  sprite: iconSpriteSchema.optional(),
+  componentPrefix: z.string().optional().default("Icon"),
+  componentSuffix: z.string().optional().default(""),
+  generateIndex: z.boolean().optional().default(true),
+  generateTypes: z.boolean().optional().default(true)
+});
+var tokenBuildConfigSchema = z.object({
+  format: outputFormatSchema,
+  outputDir: z.string().optional(),
+  outputFileName: z.string().optional(),
+  fileExtension: z.string().optional(),
+  prefix: z.string().optional(),
+  useVariables: z.boolean().optional(),
+  selector: z.string().optional(),
+  transforms: z.array(z.string()).optional(),
+  customTransforms: z.array(customTransformSchema).optional(),
+  filter: z.function().optional(),
+  header: z.string().optional(),
+  footer: z.string().optional()
+});
+var postprocessConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  cssDir: z.string().optional(),
+  files: z.array(z.string()).optional(),
+  replacements: z.array(
+    z.object({
+      description: z.string().optional(),
+      from: z.union([z.string(), z.instanceof(RegExp)]),
+      to: z.string()
+    })
+  ).optional()
+});
+var scssConfigSchema = z.object({
+  /** Output styles to generate: 'expanded' (readable) or 'compressed' (minified) */
+  outputStyles: z.array(z.enum(["expanded", "compressed"])).optional(),
+  /** Generate source maps for SCSS compilation */
+  generateSourceMaps: z.boolean().optional(),
+  /** Suffix for minified files (e.g., '.min') */
+  minifiedSuffix: z.string().optional(),
+  /** Theme entry point SCSS file */
+  themeEntry: z.string().optional(),
+  /** Utilities entry point SCSS file */
+  utilitiesEntry: z.string().optional(),
+  /** Output directory for compiled CSS files */
+  cssOutputDir: z.string().optional(),
+  /** Additional Sass load paths */
+  loadPaths: z.array(z.string()).optional(),
+  /** Target CSS framework for variable name mapping */
+  framework: z.enum(["bootstrap", "tailwind", "material", "custom"]).optional(),
+  /** Custom token to variable name mappings */
+  nameMapping: z.record(z.string(), z.string()).optional(),
+  /** Output path for Bootstrap-compatible SCSS variables */
+  variablesOutput: z.string().optional()
+});
+var tokenCacheConfigSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  directory: z.string().optional().default(".cache"),
+  hashType: hashTypeSchema.optional().default("content"),
+  maxAge: z.number().optional().default(864e5)
+});
+var tokenWatchConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  debounce: z.number().optional().default(300),
+  clearScreen: z.boolean().optional().default(true),
+  ignorePatterns: z.array(z.string()).optional().default([])
+});
+var tokensHooksSchema = z.object({
+  onBuildStart: z.function().optional(),
+  onFormatComplete: z.function().optional(),
+  onAllFormatsComplete: z.function().optional(),
+  onBuildComplete: z.function().optional(),
+  onError: z.function().optional()
+});
+var buildPipelineStepSchema = z.enum([
+  "validate",
+  "snapshot",
+  "preprocess",
+  "transform",
+  "style-dictionary",
+  "sync",
+  "sass-theme",
+  "sass-theme-minified",
+  "postprocess",
+  "sass-utilities",
+  "sass-utilities-minified",
+  "bundle"
+]);
+var tokensBuildPipelineSchema = z.object({
+  /**
+   * Steps to include in the build.
+   * Order matters - steps run in sequence.
+   * Default includes all steps for full @dsai-io/tokens build.
+   * Simpler packages can use subset like ['validate', 'transform', 'style-dictionary']
+   */
+  steps: z.array(buildPipelineStepSchema).optional(),
+  /**
+   * Paths configuration for build steps
+   */
+  paths: z.object({
+    /** Source file for sync step (Style Dictionary JS output) */
+    syncSource: z.string().optional(),
+    /** Target file for sync step */
+    syncTarget: z.string().optional(),
+    /** SCSS theme input file */
+    sassThemeInput: z.string().optional(),
+    /** CSS theme output file */
+    sassThemeOutput: z.string().optional(),
+    /** CSS theme minified output file */
+    sassThemeMinifiedOutput: z.string().optional(),
+    /** SCSS utilities input file */
+    sassUtilitiesInput: z.string().optional(),
+    /** CSS utilities output file */
+    sassUtilitiesOutput: z.string().optional(),
+    /** CSS utilities minified output file */
+    sassUtilitiesMinifiedOutput: z.string().optional()
+  }).optional(),
+  /** Style Dictionary config file name */
+  styleDictionaryConfig: z.string().optional()
+});
+var tokensConfigSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  sourcePatterns: z.array(z.string()).optional().default(["src/tokens/**/*.json", "src/tokens/**/*.yaml"]),
+  outputDirs: z.object({
+    css: z.string().optional().default("dist/css"),
+    scss: z.string().optional().default("dist/scss"),
+    less: z.string().optional().default("dist/less"),
+    js: z.string().optional().default("dist/js"),
+    ts: z.string().optional().default("dist/ts"),
+    json: z.string().optional().default("dist/json")
+  }).optional(),
+  additionalScssDirectories: z.array(z.string()).optional().default([]),
+  outputFileNames: z.object({
+    variables: z.string().optional().default("variables"),
+    utilities: z.string().optional().default("utilities"),
+    mixins: z.string().optional().default("mixins"),
+    tokens: z.string().optional().default("tokens")
+  }).optional(),
+  prefix: z.string().optional().default("dsai"),
+  mergeOrder: z.array(z.string()).optional().default(["base", "semantic", "component"]),
+  createBundle: z.boolean().optional().default(true),
+  bundleFileName: z.string().optional().default("bundle"),
+  formats: z.array(outputFormatSchema).optional().default(["css", "scss", "json"]),
+  platforms: z.record(z.string(), tokenBuildConfigSchema).optional(),
+  transforms: z.array(z.string()).optional().default([]),
+  customTransforms: z.array(customTransformSchema).optional().default([]),
+  customFormats: z.array(customFormatSchema).optional().default([]),
+  hooks: tokensHooksSchema.optional(),
+  cache: tokenCacheConfigSchema.optional(),
+  watch: tokenWatchConfigSchema.optional(),
+  verbose: z.boolean().optional().default(false),
+  /** SCSS/CSS output configuration */
+  scss: scssConfigSchema.optional(),
+  /** Build pipeline configuration */
+  pipeline: tokensBuildPipelineSchema.optional(),
+  /** Postprocess configuration */
+  postprocess: postprocessConfigSchema.optional()
+});
+var buildConfigSchema = z.object({
+  outDir: z.string().optional().default("dist"),
+  clean: z.boolean().optional().default(true),
+  sourcemap: z.boolean().optional().default(false),
+  minify: z.boolean().optional().default(true),
+  parallel: z.boolean().optional().default(true),
+  maxConcurrency: z.number().optional().default(4)
+});
+var globalConfigSchema = z.object({
+  logLevel: logLevelSchema.optional().default("info"),
+  colors: z.boolean().optional().default(true),
+  ci: z.boolean().optional().default(false),
+  dryRun: z.boolean().optional().default(false),
+  cwd: z.string().optional(),
+  configPath: z.string().optional(),
+  framework: frameworkSchema.optional(),
+  build: buildConfigSchema.optional()
+});
+var aliasesConfigSchema = z.object({
+  importAlias: z.string().optional().default("@/"),
+  ui: z.string().optional().default("src/components/ui"),
+  hooks: z.string().optional().default("src/hooks"),
+  utils: z.string().optional().default("src/lib/utils"),
+  components: z.string().optional().default("src/components"),
+  lib: z.string().optional().default("src/lib")
+});
+var componentsConfigSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  registryUrl: z.string().optional().default("https://registry.dsai.dev"),
+  tsx: z.boolean().optional().default(true),
+  overwrite: z.boolean().optional().default(false)
+});
+z.object({
+  $schema: z.string().optional(),
+  extends: z.union([z.string(), z.array(z.string())]).optional(),
+  global: globalConfigSchema.optional(),
+  tokens: tokensConfigSchema.optional(),
+  themes: themesConfigSchema.optional(),
+  icons: iconsConfigSchema.optional(),
+  aliases: aliasesConfigSchema.optional(),
+  components: componentsConfigSchema.optional()
+});
 
 // src/cli/commands/tokens.ts
+init_tokens();
+init_snapshot();
 function createTokensCommand() {
   const tokens = new Command("tokens").description("Design token operations").helpCommand("help [command]", "Show help for a command");
   tokens.command("build").description("Build design tokens").option("-p, --platforms <platforms>", "Platforms to build (comma-separated)", "all").option("-w, --watch", "Watch mode", false).option("--clean", "Clean output before build", false).option("--theme <name>", "Build only a specific theme (e.g., dark)").option("--list-themes", "List available themes from config").action(async (options, command) => {
@@ -10430,7 +10874,7 @@ function safeReadFile(basePath, ...relativePath) {
     return void 0;
   }
 }
-function detectPackageManager(cwd) {
+function detectPackageManager2(cwd) {
   const basePath = resolve(cwd);
   if (safeExists(basePath, "bun.lockb") || safeExists(basePath, "bun.lock")) {
     return "bun";
@@ -10745,7 +11189,7 @@ function detectProject(cwd = process.cwd()) {
       isMonorepo: false,
       framework: "unknown",
       metaFramework: "none",
-      packageManager: detectPackageManager(basePath),
+      packageManager: detectPackageManager2(basePath),
       typescript: false,
       esm: false,
       styling: "unknown",
@@ -10760,7 +11204,7 @@ function detectProject(cwd = process.cwd()) {
     monorepoTool: monorepoInfo.tool,
     framework: detectFramework(packageJson),
     metaFramework: detectMetaFramework(packageJson, basePath),
-    packageManager: detectPackageManager(basePath),
+    packageManager: detectPackageManager2(basePath),
     typescript: detectTypeScript(packageJson, basePath),
     esm: detectESM(packageJson, basePath),
     styling: detectStyling(packageJson, basePath),
@@ -12984,6 +13428,941 @@ async function runConfig(options) {
   }
 }
 
+// src/registry/component-map.ts
+var componentMap = {
+  accordion: {
+    type: "registry:ui",
+    title: "Accordion",
+    description: "Collapsible content panels for presenting information in a limited space.",
+    categories: ["disclosure", "layout"]
+  },
+  alert: {
+    type: "registry:ui",
+    title: "Alert",
+    description: "Contextual feedback messages for user actions.",
+    categories: ["feedback"]
+  },
+  avatar: {
+    type: "registry:ui",
+    title: "Avatar",
+    description: "Graphical representation of a user or entity.",
+    categories: ["data-display"]
+  },
+  badge: {
+    type: "registry:ui",
+    title: "Badge",
+    description: "Small count or status indicator, typically displayed on other elements.",
+    categories: ["data-display"]
+  },
+  breadcrumb: {
+    type: "registry:ui",
+    title: "Breadcrumb",
+    description: "Navigation aid showing the current page location within a hierarchy.",
+    categories: ["navigation"]
+  },
+  button: {
+    type: "registry:ui",
+    title: "Button",
+    description: "Trigger for actions and events.",
+    categories: ["actions"]
+  },
+  card: {
+    type: "registry:ui",
+    title: "Card",
+    description: "Flexible container for grouping related content and actions.",
+    categories: ["layout", "data-display"]
+  },
+  "card-list": {
+    type: "registry:ui",
+    title: "CardList",
+    description: "Responsive list of selectable cards with keyboard navigation.",
+    categories: ["layout", "data-display"]
+  },
+  carousel: {
+    type: "registry:ui",
+    title: "Carousel",
+    description: "Slideshow component for cycling through content.",
+    categories: ["data-display"]
+  },
+  checkbox: {
+    type: "registry:ui",
+    title: "Checkbox",
+    description: "Toggle control for boolean selections.",
+    categories: ["forms"]
+  },
+  "checkbox-group": {
+    type: "registry:ui",
+    title: "CheckboxGroup",
+    description: "Managed group of checkboxes with shared state.",
+    categories: ["forms"]
+  },
+  dropdown: {
+    type: "registry:ui",
+    title: "Dropdown",
+    description: "Toggleable overlay menu for displaying a list of actions.",
+    categories: ["navigation", "actions"],
+    npmDependencies: ["@floating-ui/react"]
+  },
+  icon: {
+    type: "registry:ui",
+    title: "Icon",
+    description: "Scalable vector icon component with accessibility support.",
+    categories: ["data-display"]
+  },
+  input: {
+    type: "registry:ui",
+    title: "Input",
+    description: "Text input field with validation and formatting support.",
+    categories: ["forms"]
+  },
+  "list-group": {
+    type: "registry:ui",
+    title: "ListGroup",
+    description: "Flexible component for displaying a series of items.",
+    categories: ["data-display", "navigation"]
+  },
+  modal: {
+    type: "registry:ui",
+    title: "Modal",
+    description: "Dialog overlay for focused content and user interactions.",
+    categories: ["feedback", "disclosure"]
+  },
+  navbar: {
+    type: "registry:ui",
+    title: "Navbar",
+    description: "Responsive navigation header with branding and links.",
+    categories: ["navigation"]
+  },
+  pagination: {
+    type: "registry:ui",
+    title: "Pagination",
+    description: "Navigation controls for paged content.",
+    categories: ["navigation"]
+  },
+  popover: {
+    type: "registry:ui",
+    title: "Popover",
+    description: "Floating content panel anchored to a trigger element.",
+    categories: ["disclosure"],
+    npmDependencies: ["@floating-ui/react"]
+  },
+  progress: {
+    type: "registry:ui",
+    title: "Progress",
+    description: "Visual indicator of task completion.",
+    categories: ["feedback"]
+  },
+  radio: {
+    type: "registry:ui",
+    title: "Radio",
+    description: "Single-select control within a group of options.",
+    categories: ["forms"]
+  },
+  scrollspy: {
+    type: "registry:ui",
+    title: "Scrollspy",
+    description: "Automatically highlights navigation links based on scroll position.",
+    categories: ["navigation"]
+  },
+  select: {
+    type: "registry:ui",
+    title: "Select",
+    description: "Dropdown selector for choosing from a list of options.",
+    categories: ["forms"],
+    npmDependencies: ["@floating-ui/react"]
+  },
+  "selectable-card": {
+    type: "registry:ui",
+    title: "SelectableCard",
+    description: "Card variant that acts as a selectable option.",
+    categories: ["forms", "data-display"]
+  },
+  sheet: {
+    type: "registry:ui",
+    title: "Sheet",
+    description: "Sliding panel overlay from screen edges.",
+    categories: ["disclosure", "layout"]
+  },
+  spinner: {
+    type: "registry:ui",
+    title: "Spinner",
+    description: "Loading indicator for asynchronous operations.",
+    categories: ["feedback"]
+  },
+  switch: {
+    type: "registry:ui",
+    title: "Switch",
+    description: "Toggle control for binary on/off states.",
+    categories: ["forms"]
+  },
+  table: {
+    type: "registry:ui",
+    title: "Table",
+    description: "Data table with sorting, selection, and responsive layout.",
+    categories: ["data-display"]
+  },
+  tabs: {
+    type: "registry:ui",
+    title: "Tabs",
+    description: "Tabbed interface for switching between content panels.",
+    categories: ["navigation", "layout"]
+  },
+  "tabs-pro": {
+    type: "registry:ui",
+    title: "TabsPro",
+    description: "Advanced tabbed interface with closable, sortable, and overflow support.",
+    categories: ["navigation", "layout"]
+  },
+  toast: {
+    type: "registry:ui",
+    title: "Toast",
+    description: "Brief notification messages that auto-dismiss.",
+    categories: ["feedback"]
+  },
+  tooltip: {
+    type: "registry:ui",
+    title: "Tooltip",
+    description: "Informational popup displayed on hover or focus.",
+    categories: ["data-display"],
+    npmDependencies: ["@floating-ui/react"]
+  },
+  typography: {
+    type: "registry:ui",
+    title: "Typography",
+    description: "Text rendering primitives with semantic variants.",
+    categories: ["data-display"]
+  }
+};
+var hookMap = {
+  "use-async": {
+    type: "registry:hook",
+    title: "useAsync",
+    description: "Manages async operation lifecycle (loading, error, data states).",
+    categories: ["state"]
+  },
+  "use-callback-ref": {
+    type: "registry:hook",
+    title: "useCallbackRef",
+    description: "Stable callback reference that always points to the latest function.",
+    categories: ["refs"]
+  },
+  "use-click-outside": {
+    type: "registry:hook",
+    title: "useClickOutside",
+    description: "Detects clicks outside of a target element.",
+    categories: ["dom"]
+  },
+  "use-controllable-state": {
+    type: "registry:hook",
+    title: "useControllableState",
+    description: "Manages state that can be either controlled or uncontrolled.",
+    categories: ["state"]
+  },
+  "use-dark-mode": {
+    type: "registry:hook",
+    title: "useDarkMode",
+    description: "Detects and toggles dark mode preference.",
+    categories: ["theme"]
+  },
+  "use-debounce": {
+    type: "registry:hook",
+    title: "useDebounce",
+    description: "Debounces a value or callback over a specified delay.",
+    categories: ["timing"]
+  },
+  "use-field": {
+    type: "registry:hook",
+    title: "useField",
+    description: "Form field state management with validation.",
+    categories: ["forms"]
+  },
+  "use-focus-trap": {
+    type: "registry:hook",
+    title: "useFocusTrap",
+    description: "Traps keyboard focus within a container for modal-like experiences.",
+    categories: ["a11y"]
+  },
+  "use-form": {
+    type: "registry:hook",
+    title: "useForm",
+    description: "Comprehensive form state management with validation.",
+    categories: ["forms"]
+  },
+  "use-hover": {
+    type: "registry:hook",
+    title: "useHover",
+    description: "Tracks hover state of an element with enter/leave delays.",
+    categories: ["dom"]
+  },
+  "use-id": {
+    type: "registry:hook",
+    title: "useId",
+    description: "Generates stable unique identifiers for accessibility attributes.",
+    categories: ["a11y"]
+  },
+  "use-intersection-observer": {
+    type: "registry:hook",
+    title: "useIntersectionObserver",
+    description: "Observes element visibility within the viewport.",
+    categories: ["dom"]
+  },
+  "use-key-press": {
+    type: "registry:hook",
+    title: "useKeyPress",
+    description: "Listens for specific keyboard key presses.",
+    categories: ["dom"]
+  },
+  "use-local-storage": {
+    type: "registry:hook",
+    title: "useLocalStorage",
+    description: "Persists state to localStorage with serialization.",
+    categories: ["state", "storage"]
+  },
+  "use-media-query": {
+    type: "registry:hook",
+    title: "useMediaQuery",
+    description: "Matches CSS media queries and provides responsive breakpoint helpers.",
+    categories: ["responsive"]
+  },
+  "use-mounted": {
+    type: "registry:hook",
+    title: "useMounted",
+    description: "Tracks whether the component is currently mounted.",
+    categories: ["lifecycle"]
+  },
+  "use-previous": {
+    type: "registry:hook",
+    title: "usePrevious",
+    description: "Returns the previous value of a variable across renders.",
+    categories: ["state"]
+  },
+  "use-reduced-motion": {
+    type: "registry:hook",
+    title: "useReducedMotion",
+    description: "Detects user preference for reduced motion.",
+    categories: ["a11y"]
+  },
+  "use-resize-observer": {
+    type: "registry:hook",
+    title: "useResizeObserver",
+    description: "Observes element size changes via ResizeObserver.",
+    categories: ["dom"]
+  },
+  "use-roving-focus": {
+    type: "registry:hook",
+    title: "useRovingFocus",
+    description: "Implements roving tabindex pattern for composite widgets.",
+    categories: ["a11y"]
+  },
+  "use-scroll-lock": {
+    type: "registry:hook",
+    title: "useScrollLock",
+    description: "Prevents body scrolling while active (for modals/overlays).",
+    categories: ["dom"]
+  },
+  "use-session-storage": {
+    type: "registry:hook",
+    title: "useSessionStorage",
+    description: "Persists state to sessionStorage with serialization.",
+    categories: ["state", "storage"]
+  },
+  "use-throttle": {
+    type: "registry:hook",
+    title: "useThrottle",
+    description: "Throttles a value or callback to fire at most once per interval.",
+    categories: ["timing"]
+  }
+};
+var utilMap = {
+  cn: {
+    type: "registry:util",
+    title: "cn",
+    description: "Conditional class name composition utility.",
+    categories: ["styling"]
+  },
+  a11y: {
+    type: "registry:util",
+    title: "a11y",
+    description: "Accessibility utilities including screen reader announcements and ARIA helpers.",
+    categories: ["a11y"]
+  },
+  async: {
+    type: "registry:util",
+    title: "async",
+    description: "Async operation utilities: abortable tasks, queues, exponential backoff.",
+    categories: ["async"]
+  },
+  browser: {
+    type: "registry:util",
+    title: "browser",
+    description: "Browser environment detection and feature checks.",
+    categories: ["platform"]
+  },
+  collections: {
+    type: "registry:util",
+    title: "collections",
+    description: "Collection utilities: chunk, paginate, memoize, selectors.",
+    categories: ["data"]
+  },
+  color: {
+    type: "registry:util",
+    title: "color",
+    description: "Color manipulation utilities: contrast, luminance, hex/rgb conversion.",
+    categories: ["styling"]
+  },
+  date: {
+    type: "registry:util",
+    title: "date",
+    description: "Date formatting and relative time utilities.",
+    categories: ["formatting"]
+  },
+  "merge-refs": {
+    type: "registry:util",
+    title: "mergeRefs",
+    description: "Merges multiple React refs into a single callback ref.",
+    categories: ["refs"]
+  },
+  dx: {
+    type: "registry:util",
+    title: "dx",
+    description: "Developer experience helpers: component creation, context factories, polymorphic patterns.",
+    categories: ["dx"]
+  },
+  forms: {
+    type: "registry:util",
+    title: "forms",
+    description: "Form utilities: validators, field error extraction, dirty checking.",
+    categories: ["forms"]
+  },
+  keyboard: {
+    type: "registry:util",
+    title: "keyboard",
+    description: "Keyboard event helpers for detecting specific keys.",
+    categories: ["dom"]
+  },
+  layout: {
+    type: "registry:util",
+    title: "layout",
+    description: "Layout measurement utilities: element bounds, viewport size, resize observation.",
+    categories: ["dom"]
+  },
+  misc: {
+    type: "registry:util",
+    title: "misc",
+    description: "Miscellaneous utilities: clear icon, safe input props, event helpers.",
+    categories: ["misc"]
+  },
+  motion: {
+    type: "registry:util",
+    title: "motion",
+    description: "Animation utilities: spring physics, easing functions, distance calculations.",
+    categories: ["animation"]
+  },
+  number: {
+    type: "registry:util",
+    title: "number",
+    description: "Number formatting and clamping utilities.",
+    categories: ["formatting"]
+  },
+  object: {
+    type: "registry:util",
+    title: "object",
+    description: "Object manipulation utilities: deep merge, pick, omit.",
+    categories: ["data"]
+  },
+  platform: {
+    type: "registry:util",
+    title: "platform",
+    description: "Platform detection utilities: browser, OS, device pixel ratio, text direction.",
+    categories: ["platform"]
+  },
+  responsive: {
+    type: "registry:util",
+    title: "responsive",
+    description: "Responsive design utilities.",
+    categories: ["responsive"]
+  },
+  safety: {
+    type: "registry:util",
+    title: "safety",
+    description: "Security utilities: clipboard access, crypto ID generation, token generation.",
+    categories: ["security"]
+  },
+  string: {
+    type: "registry:util",
+    title: "string",
+    description: "String manipulation utilities: capitalize, slugify, variant classes.",
+    categories: ["formatting"]
+  },
+  telemetry: {
+    type: "registry:util",
+    title: "telemetry",
+    description: "Telemetry utilities: error catching, performance measurement, timing.",
+    categories: ["observability"]
+  },
+  timing: {
+    type: "registry:util",
+    title: "timing",
+    description: "Timing utilities: debounce and throttle functions.",
+    categories: ["timing"]
+  },
+  types: {
+    type: "registry:util",
+    title: "types",
+    description: "Shared type guards and type utilities.",
+    categories: ["types"]
+  },
+  validation: {
+    type: "registry:util",
+    title: "validation",
+    description: "Input validation utilities: email, URL, href safety checks.",
+    categories: ["validation"]
+  }
+};
+var directoryToRegistryName = {
+  Accordion: "accordion",
+  Alert: "alert",
+  Avatar: "avatar",
+  Badge: "badge",
+  Breadcrumb: "breadcrumb",
+  Button: "button",
+  Card: "card",
+  CardList: "card-list",
+  Carousel: "carousel",
+  Checkbox: "checkbox",
+  CheckboxGroup: "checkbox-group",
+  Dropdown: "dropdown",
+  Icon: "icon",
+  Input: "input",
+  ListGroup: "list-group",
+  Modal: "modal",
+  Navbar: "navbar",
+  Pagination: "pagination",
+  Popover: "popover",
+  Progress: "progress",
+  Radio: "radio",
+  Scrollspy: "scrollspy",
+  Select: "select",
+  SelectableCard: "selectable-card",
+  Sheet: "sheet",
+  Spinner: "spinner",
+  Switch: "switch",
+  Table: "table",
+  Tabs: "tabs",
+  TabsPro: "tabs-pro",
+  Toast: "toast",
+  Tooltip: "tooltip",
+  Typography: "typography"
+};
+var hookDirectoryToRegistryName = {
+  useAsync: "use-async",
+  useCallbackRef: "use-callback-ref",
+  useClickOutside: "use-click-outside",
+  useControllableState: "use-controllable-state",
+  useDarkMode: "use-dark-mode",
+  useDebounce: "use-debounce",
+  useField: "use-field",
+  useFocusTrap: "use-focus-trap",
+  useForm: "use-form",
+  useHover: "use-hover",
+  useId: "use-id",
+  useIntersectionObserver: "use-intersection-observer",
+  useKeyPress: "use-key-press",
+  useLocalStorage: "use-local-storage",
+  useMediaQuery: "use-media-query",
+  useMounted: "use-mounted",
+  usePrevious: "use-previous",
+  useReducedMotion: "use-reduced-motion",
+  useResizeObserver: "use-resize-observer",
+  useRovingFocus: "use-roving-focus",
+  useScrollLock: "use-scroll-lock",
+  useSessionStorage: "use-session-storage",
+  useThrottle: "use-throttle"
+};
+
+// src/registry/builder.ts
+var EXCLUDE_PATTERNS = [
+  /\.test\.(tsx?|jsx?)$/,
+  /\.spec\.(tsx?|jsx?)$/,
+  /\.stories\.(tsx?|jsx?)$/,
+  /\.figma\.(tsx?|jsx?)$/,
+  /\.a11y\.test\./,
+  /\.security\.test\./,
+  /\.integration\.test\./,
+  /README\.md$/
+];
+var REACT_BUILTINS = /* @__PURE__ */ new Set(["react", "react-dom", "react/jsx-runtime", "react-dom/client"]);
+var UTIL_SUBPATH_TO_REGISTRY = {
+  index: "cn",
+  keyboard: "keyboard",
+  dom: "merge-refs",
+  "dom/mergeRefs": "merge-refs",
+  browser: "browser",
+  validation: "validation",
+  string: "string",
+  misc: "misc",
+  a11y: "a11y",
+  types: "types",
+  async: "async",
+  collections: "collections",
+  color: "color",
+  date: "date",
+  dx: "dx",
+  forms: "forms",
+  layout: "layout",
+  motion: "motion",
+  number: "number",
+  object: "object",
+  platform: "platform",
+  responsive: "responsive",
+  safety: "safety",
+  telemetry: "telemetry",
+  timing: "timing"
+};
+function shouldIncludeFile(filePath) {
+  const ext = extname(filePath);
+  if (![".ts", ".tsx", ".css"].includes(ext)) return false;
+  return !EXCLUDE_PATTERNS.some((pattern) => pattern.test(filePath));
+}
+function readSourceFiles(dirPath) {
+  if (!existsSync(dirPath) || !statSync(dirPath).isDirectory()) return [];
+  const results = [];
+  for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+    const fullPath = join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      for (const sub of readdirSync(fullPath, { withFileTypes: true })) {
+        if (sub.isFile()) {
+          const subPath = join(fullPath, sub.name);
+          if (shouldIncludeFile(subPath)) {
+            results.push({ path: relative(dirPath, subPath), content: readFileSync(subPath, "utf-8") });
+          }
+        }
+      }
+    } else if (entry.isFile() && shouldIncludeFile(fullPath)) {
+      results.push({ path: entry.name, content: readFileSync(fullPath, "utf-8") });
+    }
+  }
+  return results;
+}
+function extractCnSource(utilsIndexPath) {
+  const content = readFileSync(utilsIndexPath, "utf-8");
+  const cnPattern = /(\/\*\*[\s\S]*?\*\/\s*)?export function cn\b[\s\S]*?\n\}/;
+  const match = cnPattern.exec(content);
+  return match ? match[0] : "export function cn(...classes: (string | boolean | undefined | null)[]): string {\n  return classes.filter(Boolean).join(' ');\n}";
+}
+function analyzeImports(files, knownNpmDeps) {
+  const registryDeps = /* @__PURE__ */ new Set();
+  const npmDeps = new Set(knownNpmDeps);
+  const importPattern = /(?:import|export)\s+(?:[\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
+  for (const file of files) {
+    let m2;
+    importPattern.lastIndex = 0;
+    while ((m2 = importPattern.exec(file.content)) !== null) {
+      const specifier = m2[1] ?? "";
+      const typesPattern = /\.\.\/(?:\.\.\/)?types(?:\/.*)?$/;
+      if (typesPattern.test(specifier)) {
+        registryDeps.add("dsai-types");
+        continue;
+      }
+      const hookPattern = /\.\.\/(?:\.\.\/)?hooks\/(\w+)/;
+      const hookMatch = hookPattern.exec(specifier);
+      if (hookMatch && hookMatch[1]) {
+        const regName = hookDirectoryToRegistryName[hookMatch[1]];
+        if (regName) registryDeps.add(regName);
+        continue;
+      }
+      const utilPattern = /\.\.\/(?:\.\.\/)?utils(?:\/(.+))?$/;
+      const utilMatch = utilPattern.exec(specifier);
+      if (utilMatch) {
+        const subpath = utilMatch[1] ?? "index";
+        const regName = UTIL_SUBPATH_TO_REGISTRY[subpath];
+        if (regName) registryDeps.add(regName);
+        continue;
+      }
+      const compPattern = /^\.\.\/(\.\.\/)?(?:components\/)?([A-Z]\w+)(?:\/.*)?$/;
+      const compMatch = compPattern.exec(specifier);
+      if (compMatch && compMatch[2]) {
+        const compDir = compMatch[2];
+        const regName = directoryToRegistryName[compDir];
+        if (regName) registryDeps.add(regName);
+        continue;
+      }
+      if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+        const parts = specifier.split("/");
+        const pkgName = specifier.startsWith("@") && parts.length >= 2 ? `${parts[0]}/${parts[1]}` : parts[0] ?? specifier;
+        if (pkgName && !REACT_BUILTINS.has(pkgName) && !pkgName.startsWith("@dsai-io/")) {
+          npmDeps.add(pkgName);
+        }
+      }
+    }
+  }
+  return { registryDeps, npmDeps };
+}
+function buildComponentItem(name, dirPath, log) {
+  const meta = componentMap[name];
+  if (!meta) {
+    log(`  [WARN] No metadata for component "${name}", skipping`);
+    return null;
+  }
+  const sourceFiles = readSourceFiles(dirPath);
+  if (sourceFiles.length === 0) {
+    log(`  [WARN] No source files found in ${dirPath}`);
+    return null;
+  }
+  const { registryDeps, npmDeps } = analyzeImports(sourceFiles, meta.npmDependencies ?? []);
+  const files = sourceFiles.map((f) => ({
+    path: f.path,
+    type: extname(f.path) === ".css" ? "registry:style" : meta.type,
+    content: f.content
+  }));
+  return {
+    name,
+    type: meta.type,
+    title: meta.title,
+    description: meta.description,
+    dependencies: [...npmDeps].sort(),
+    devDependencies: [],
+    registryDependencies: [...registryDeps].sort(),
+    files,
+    categories: meta.categories
+  };
+}
+function buildHookItem(name, dirPath, log) {
+  const meta = hookMap[name];
+  if (!meta) {
+    log(`  [WARN] No metadata for hook "${name}", skipping`);
+    return null;
+  }
+  const sourceFiles = readSourceFiles(dirPath);
+  if (sourceFiles.length === 0) {
+    log(`  [WARN] No source files found in ${dirPath}`);
+    return null;
+  }
+  const { registryDeps, npmDeps } = analyzeImports(sourceFiles, meta.npmDependencies ?? []);
+  const files = sourceFiles.map((f) => ({
+    path: f.path,
+    type: extname(f.path) === ".css" ? "registry:style" : meta.type,
+    content: f.content
+  }));
+  return {
+    name,
+    type: meta.type,
+    title: meta.title,
+    description: meta.description,
+    dependencies: [...npmDeps].sort(),
+    devDependencies: [],
+    registryDependencies: [...registryDeps].sort(),
+    files,
+    categories: meta.categories
+  };
+}
+function buildUtilItem(name, reactSrcDir, log) {
+  const meta = utilMap[name];
+  if (!meta) {
+    log(`  [WARN] No metadata for util "${name}", skipping`);
+    return null;
+  }
+  let files;
+  let registryDeps = /* @__PURE__ */ new Set();
+  let npmDeps = /* @__PURE__ */ new Set();
+  if (name === "cn") {
+    const indexPath = join(reactSrcDir, "utils", "index.ts");
+    const cnSource = extractCnSource(indexPath);
+    files = [{ path: "cn.ts", type: "registry:util", content: cnSource }];
+  } else if (name === "merge-refs") {
+    const dirPath = join(reactSrcDir, "utils", "dom");
+    const sourceFiles = readSourceFiles(dirPath);
+    const analyzed = analyzeImports(sourceFiles, []);
+    registryDeps = analyzed.registryDeps;
+    npmDeps = analyzed.npmDeps;
+    files = sourceFiles.map((f) => ({
+      path: `dom/${f.path}`,
+      type: extname(f.path) === ".css" ? "registry:style" : "registry:util",
+      content: f.content
+    }));
+  } else {
+    const dirPath = join(reactSrcDir, "utils", name);
+    if (!existsSync(dirPath) || !statSync(dirPath).isDirectory()) {
+      log(`  [WARN] Util directory not found: ${dirPath}`);
+      return null;
+    }
+    const sourceFiles = readSourceFiles(dirPath);
+    if (sourceFiles.length === 0) {
+      log(`  [WARN] No source files found in ${dirPath}`);
+      return null;
+    }
+    const analyzed = analyzeImports(sourceFiles, []);
+    registryDeps = analyzed.registryDeps;
+    npmDeps = analyzed.npmDeps;
+    files = sourceFiles.map((f) => ({
+      path: `${name}/${f.path}`,
+      type: extname(f.path) === ".css" ? "registry:style" : "registry:util",
+      content: f.content
+    }));
+  }
+  return {
+    name,
+    type: meta.type,
+    title: meta.title,
+    description: meta.description,
+    dependencies: [...npmDeps].sort(),
+    devDependencies: [],
+    registryDependencies: [...registryDeps].sort(),
+    files,
+    categories: meta.categories
+  };
+}
+function buildTypesItem(reactSrcDir, log) {
+  const typesDir = join(reactSrcDir, "types");
+  const sourceFiles = readSourceFiles(typesDir);
+  if (sourceFiles.length === 0) {
+    log("  [WARN] No type files found");
+    return null;
+  }
+  const files = sourceFiles.map((f) => {
+    let content = f.content;
+    content = content.replace(/export \{[^}]*\} from ['"]\.\.\/utils\/[^'"]+['"];?\n?/g, "");
+    return {
+      path: `types/${f.path}`,
+      type: "registry:type",
+      content
+    };
+  });
+  return {
+    name: "dsai-types",
+    type: "registry:type",
+    title: "Shared Types",
+    description: "Shared type definitions (SafeHTMLAttributes, ComponentSize, PolymorphicComponentProps, etc.)",
+    dependencies: [],
+    devDependencies: [],
+    registryDependencies: [],
+    files,
+    categories: ["types"]
+  };
+}
+function buildRegistry(options) {
+  const { reactSrcDir, outputDir, verbose = false } = options;
+  const log = verbose ? (msg) => console.log(msg) : (_msg) => {
+  };
+  const componentsDir = join(reactSrcDir, "components");
+  const hooksDir = join(reactSrcDir, "hooks");
+  const allItems = [];
+  log("[registry] Scanning components...");
+  if (existsSync(componentsDir)) {
+    for (const entry of readdirSync(componentsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const dirName = entry.name;
+      const registryName = directoryToRegistryName[dirName];
+      if (!registryName) {
+        log(`  [SKIP] Unknown component directory: ${dirName}`);
+        continue;
+      }
+      log(`  Building ${registryName}...`);
+      const item = buildComponentItem(registryName, join(componentsDir, dirName), log);
+      if (item) allItems.push(item);
+    }
+  }
+  log("[registry] Scanning hooks...");
+  if (existsSync(hooksDir)) {
+    for (const entry of readdirSync(hooksDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const dirName = entry.name;
+      const registryName = hookDirectoryToRegistryName[dirName];
+      if (!registryName) {
+        log(`  [SKIP] Unknown hook directory: ${dirName}`);
+        continue;
+      }
+      log(`  Building ${registryName}...`);
+      const item = buildHookItem(registryName, join(hooksDir, dirName), log);
+      if (item) allItems.push(item);
+    }
+  }
+  log("[registry] Scanning utils...");
+  for (const name of Object.keys(utilMap)) {
+    log(`  Building ${name}...`);
+    const item = buildUtilItem(name, reactSrcDir, log);
+    if (item) allItems.push(item);
+  }
+  log("[registry] Building shared types...");
+  const typesItem = buildTypesItem(reactSrcDir, log);
+  if (typesItem) {
+    allItems.push(typesItem);
+    log(`  Built dsai-types (${typesItem.files.length} files)`);
+  }
+  log(`[registry] Writing ${allItems.length} items to ${outputDir}...`);
+  for (const sub of ["components", "hooks", "utils", "types"]) {
+    const dir = join(outputDir, sub);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+  const typeToSubdir = {
+    "registry:ui": "components",
+    "registry:component": "components",
+    "registry:hook": "hooks",
+    "registry:util": "utils",
+    "registry:lib": "utils",
+    "registry:type": "types"
+  };
+  for (const item of allItems) {
+    const subdir = typeToSubdir[item.type] ?? "utils";
+    const filePath = join(outputDir, subdir, `${item.name}.json`);
+    writeFileSync(filePath, JSON.stringify(item, null, 2) + "\n", "utf-8");
+    log(`  Wrote ${relative(outputDir, filePath)}`);
+  }
+  const indexEntries = allItems.map((item) => ({
+    name: item.name,
+    type: item.type,
+    title: item.title,
+    description: item.description,
+    dependencies: item.dependencies,
+    registryDependencies: item.registryDependencies,
+    categories: item.categories
+  }));
+  const registryIndex = {
+    version: "0.1.0",
+    count: indexEntries.length,
+    items: indexEntries
+  };
+  writeFileSync(join(outputDir, "index.json"), JSON.stringify(registryIndex, null, 2) + "\n", "utf-8");
+  log(`[registry] Wrote index.json (${registryIndex.count} items)`);
+  return registryIndex;
+}
+
+// src/cli/commands/registry.ts
+function createRegistryCommand() {
+  const cmd = new Command("registry").description("Manage the component registry");
+  cmd.command("build").description("Build registry JSON from @dsai-io/react source").option("--src <path>", "Path to @dsai-io/react/src directory").option("--out <path>", "Output directory for registry JSON", "registry").option("--verbose", "Show detailed logging", false).action(async (opts) => {
+    const logger = createLogger(opts);
+    const spinner = createSpinner();
+    spinner.start("Building component registry...");
+    try {
+      const reactSrcDir = opts.src ? resolve(opts.src) : resolve(process.cwd(), "packages", "@dsai-io", "react", "src");
+      const outputDir = resolve(
+        process.cwd(),
+        "packages",
+        "@dsai-io",
+        "tools",
+        opts.out
+      );
+      const index = buildRegistry({
+        reactSrcDir,
+        outputDir,
+        verbose: opts.verbose
+      });
+      spinner.succeed(
+        `Registry built: ${colors.bold(String(index.count))} items (${index.items.filter((i) => i.type === "registry:ui").length} components, ${index.items.filter((i) => i.type === "registry:hook").length} hooks, ${index.items.filter((i) => i.type === "registry:util").length} utils)`
+      );
+      console.log(`
+  Output: ${colors.cyan(outputDir)}
+`);
+    } catch (err) {
+      spinner.fail("Failed to build registry");
+      logger.error(err.message);
+      process.exit(ExitCode.GeneralError);
+    }
+  });
+  return cmd;
+}
+
 // src/version.ts
 var version = "0.0.1";
 
@@ -13002,6 +14381,15 @@ Build, validate, and manage design tokens and icons.`
     "after",
     `
 ${colors.bold("Examples:")}
+  ${colors.muted("# Add components, hooks, or utils to your project")}
+  $ dsai add button modal use-focus-trap cn
+
+  ${colors.muted("# List everything available")}
+  $ dsai add --list
+
+  ${colors.muted("# Add all hooks")}
+  $ dsai add --all --type hook
+
   ${colors.muted("# Initialize configuration")}
   $ dsai init
 
@@ -13039,16 +14427,24 @@ function setupErrorHandling(program2) {
 var program;
 async function run(args = process.argv) {
   program = createProgram();
+  program.addCommand(createAddCommand());
   program.addCommand(createTokensCommand());
   program.addCommand(createIconsCommand());
   program.addCommand(createInitCommand());
   program.addCommand(createConfigCommand());
+  program.addCommand(createRegistryCommand());
   setupErrorHandling(program);
   await program.parseAsync(args);
 }
 function getProgram() {
   return program;
 }
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  run().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+  });
+}
 
 export { ExitCode, colors, createLogger, createSpinner, formatBytes, formatCount, formatDuration, getProgram, run };
 //# sourceMappingURL=index.js.map