@omnitron-dev/prism 0.1.1

package/dist/cli/index.js

@@ -0,0 +1,2695 @@
+import { createRequire } from 'module';
+import * as fs6 from 'fs';
+import * as path from 'path';
+import { Command } from 'commander';
+import * as readline from 'readline';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var require2, pkg, PRISM_VERSION, CONFIG_FILE_NAME, DEFAULT_COMPONENTS_DIR, DEFAULT_BLOCKS_DIR, DEFAULT_HOOKS_DIR, DEFAULT_UTILS_DIR, DEFAULT_REGISTRY_URL, DEFAULT_CONFIG, supportsColor, COLORS, log, COMPONENT_CATEGORIES, BLOCK_CATEGORIES;
+var init_constants = __esm({
+  "src/cli/constants.ts"() {
+    require2 = createRequire(import.meta.url);
+    pkg = require2("../../package.json");
+    PRISM_VERSION = pkg.version;
+    CONFIG_FILE_NAME = "prism.config.json";
+    DEFAULT_COMPONENTS_DIR = "src/components/ui";
+    DEFAULT_BLOCKS_DIR = "src/blocks";
+    DEFAULT_HOOKS_DIR = "src/hooks";
+    DEFAULT_UTILS_DIR = "src/utils";
+    DEFAULT_REGISTRY_URL = "https://registry.prism.omnitron.dev";
+    DEFAULT_CONFIG = {
+      $schema: "https://prism.omnitron.dev/schema.json",
+      style: "default",
+      tailwind: {
+        config: "tailwind.config.js",
+        css: "src/index.css",
+        baseColor: "slate",
+        cssVariables: true
+      },
+      aliases: {
+        components: "@/components/ui",
+        blocks: "@/blocks",
+        hooks: "@/hooks",
+        utils: "@/utils"
+      },
+      registries: [DEFAULT_REGISTRY_URL]
+    };
+    supportsColor = !process.env.NO_COLOR && process.stderr.isTTY !== false;
+    COLORS = supportsColor ? {
+      primary: "\x1B[36m",
+      success: "\x1B[32m",
+      warning: "\x1B[33m",
+      error: "\x1B[31m",
+      muted: "\x1B[90m",
+      bold: "\x1B[1m",
+      reset: "\x1B[0m"
+    } : {
+      primary: "",
+      success: "",
+      warning: "",
+      error: "",
+      muted: "",
+      bold: "",
+      reset: ""
+    };
+    log = {
+      info: (msg) => console.log(`${COLORS.primary}\u2139${COLORS.reset} ${msg}`),
+      success: (msg) => console.log(`${COLORS.success}\u2713${COLORS.reset} ${msg}`),
+      warning: (msg) => console.log(`${COLORS.warning}\u26A0${COLORS.reset} ${msg}`),
+      error: (msg) => console.error(`${COLORS.error}\u2716${COLORS.reset} ${msg}`),
+      muted: (msg) => console.log(`${COLORS.muted}${msg}${COLORS.reset}`)
+    };
+    COMPONENT_CATEGORIES = [
+      "inputs",
+      "data-display",
+      "feedback",
+      "surfaces",
+      "navigation",
+      "layout",
+      "data"
+    ];
+    BLOCK_CATEGORIES = ["layouts", "auth", "settings", "data", "dashboard", "marketing"];
+  }
+});
+function findConfigFile(startDir = process.cwd()) {
+  let currentDir = path.resolve(startDir);
+  const root = path.parse(currentDir).root;
+  while (currentDir !== root) {
+    const configPath = path.join(currentDir, CONFIG_FILE_NAME);
+    if (fs6.existsSync(configPath)) {
+      return configPath;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  return null;
+}
+async function loadConfig(cwd = process.cwd()) {
+  const configPath = findConfigFile(cwd);
+  if (!configPath) {
+    return null;
+  }
+  try {
+    const content = await fs6.promises.readFile(configPath, "utf-8");
+    const config = JSON.parse(content);
+    return {
+      ...DEFAULT_CONFIG,
+      ...config,
+      rootDir: path.dirname(configPath),
+      configPath
+    };
+  } catch (error) {
+    log.error(`Failed to load config: ${error.message}`);
+    return null;
+  }
+}
+async function saveConfig(config, outputPath = path.join(process.cwd(), CONFIG_FILE_NAME)) {
+  const content = JSON.stringify(config, null, 2);
+  await fs6.promises.writeFile(outputPath, content, "utf-8");
+}
+function resolveAlias(alias, config) {
+  if (alias.startsWith("@/")) {
+    return path.join(config.rootDir, "src", alias.slice(2));
+  }
+  if (alias.startsWith("~/")) {
+    return path.join(config.rootDir, alias.slice(2));
+  }
+  if (alias.startsWith("./") || alias.startsWith("../")) {
+    return path.join(config.rootDir, alias);
+  }
+  return path.join(config.rootDir, alias);
+}
+function getComponentPath(componentName, config) {
+  const componentsDir = resolveAlias(config.aliases.components, config);
+  return path.join(componentsDir, componentName);
+}
+function getBlockPath(blockName, config) {
+  const blocksDir = resolveAlias(config.aliases.blocks, config);
+  return path.join(blocksDir, blockName);
+}
+var init_config = __esm({
+  "src/cli/config.ts"() {
+    init_constants();
+  }
+});
+
+// src/registry/manager.ts
+var RegistryManager;
+var init_manager = __esm({
+  "src/registry/manager.ts"() {
+    RegistryManager = class {
+      options;
+      registries = /* @__PURE__ */ new Map();
+      cache = /* @__PURE__ */ new Map();
+      loaders = /* @__PURE__ */ new Map();
+      constructor(options = {}) {
+        this.options = {
+          baseDir: options.baseDir ?? (typeof process !== "undefined" && process.cwd ? process.cwd() : "/"),
+          defaultRegistry: options.defaultRegistry ?? "prism",
+          config: options.config ?? { default: "prism", registries: {} },
+          cacheTtl: options.cacheTtl ?? 5 * 60 * 1e3
+          // 5 minutes
+        };
+      }
+      // ===========================================================================
+      // REGISTRY LOADING
+      // ===========================================================================
+      /**
+       * Register a custom loader for a registry.
+       */
+      registerLoader(name, loader) {
+        this.loaders.set(name, loader);
+      }
+      /**
+       * Load a registry by name.
+       */
+      async loadRegistry(name) {
+        const cached = this.cache.get(name);
+        if (cached && Date.now() - cached.timestamp < this.options.cacheTtl) {
+          return cached.data;
+        }
+        const existing = this.registries.get(name);
+        if (existing && !cached) {
+          return existing;
+        }
+        const customLoader = this.loaders.get(name);
+        if (customLoader) {
+          const registry3 = await customLoader();
+          this.cacheRegistry(name, registry3);
+          return registry3;
+        }
+        const config = this.options.config.registries[name];
+        if (!config) {
+          throw new Error(`Registry "${name}" not found in configuration`);
+        }
+        const registry2 = typeof config === "string" ? await this.loadFromPath(config) : await this.loadFromRemote(config);
+        if (registry2.extends) {
+          const baseRegistry = await this.loadRegistry(registry2.extends);
+          const merged = this.mergeRegistries(baseRegistry, registry2);
+          this.cacheRegistry(name, merged);
+          return merged;
+        }
+        this.cacheRegistry(name, registry2);
+        return registry2;
+      }
+      /**
+       * Load registry from local file path.
+       * Uses dynamic import for ESM compatibility across environments.
+       *
+       * @param path - Relative or absolute path to registry JSON
+       * @returns Loaded registry schema
+       */
+      async loadFromPath(path9) {
+        const fullPath = path9.startsWith("/") ? path9 : `${this.options.baseDir}/${path9}`;
+        if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
+          const fs9 = await import('fs/promises');
+          const content = await fs9.readFile(fullPath, "utf-8");
+          return JSON.parse(content);
+        }
+        if (path9.startsWith("http://") || path9.startsWith("https://")) {
+          const response = await fetch(path9);
+          if (!response.ok) {
+            throw new Error(`Failed to load registry from ${path9}: ${response.statusText}`);
+          }
+          return response.json();
+        }
+        throw new Error(
+          `Cannot load local file "${fullPath}" in browser environment. Register a custom loader with manager.registerLoader() or use a remote URL.`
+        );
+      }
+      /**
+       * Load registry from remote URL.
+       */
+      async loadFromRemote(config) {
+        const response = await fetch(config.url, {
+          headers: config.headers
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to load registry from ${config.url}: ${response.statusText}`);
+        }
+        return response.json();
+      }
+      /**
+       * Cache a loaded registry.
+       */
+      cacheRegistry(name, registry2) {
+        this.registries.set(name, registry2);
+        this.cache.set(name, {
+          data: registry2,
+          timestamp: Date.now()
+        });
+      }
+      /**
+       * Merge two registries (base + extension).
+       */
+      mergeRegistries(base, extension) {
+        return {
+          ...base,
+          ...extension,
+          components: { ...base.components, ...extension.components },
+          blocks: { ...base.blocks, ...extension.blocks },
+          themes: { ...base.themes, ...extension.themes }
+        };
+      }
+      /**
+       * Clear registry cache.
+       */
+      clearCache(name) {
+        if (name) {
+          this.cache.delete(name);
+        } else {
+          this.cache.clear();
+        }
+      }
+      // ===========================================================================
+      // COMPONENT OPERATIONS
+      // ===========================================================================
+      /**
+       * Get a component definition by name.
+       */
+      async getComponent(name, registryName) {
+        const registry2 = await this.loadRegistry(registryName ?? this.options.defaultRegistry);
+        return registry2.components[name] ?? null;
+      }
+      /**
+       * Get all components from a registry.
+       */
+      async getComponents(registryName) {
+        const registry2 = await this.loadRegistry(registryName ?? this.options.defaultRegistry);
+        return registry2.components;
+      }
+      /**
+       * Search for components.
+       */
+      async searchComponents(options, registryName) {
+        const registry2 = await this.loadRegistry(registryName ?? this.options.defaultRegistry);
+        let results = Object.values(registry2.components);
+        if (options.category) {
+          results = results.filter((c) => c.category === options.category);
+        }
+        if (options.query) {
+          const query = options.query.toLowerCase();
+          results = results.filter(
+            (c) => c.name.toLowerCase().includes(query) || c.displayName?.toLowerCase().includes(query) || c.description?.toLowerCase().includes(query)
+          );
+        }
+        if (options.limit && options.limit > 0) {
+          results = results.slice(0, options.limit);
+        }
+        return results;
+      }
+      /**
+       * Get component categories.
+       */
+      async getComponentCategories(registryName) {
+        const registry2 = await this.loadRegistry(registryName ?? this.options.defaultRegistry);
+        const categories = /* @__PURE__ */ new Set();
+        for (const component of Object.values(registry2.components)) {
+          categories.add(component.category);
+        }
+        return Array.from(categories).sort();
+      }
+      // ===========================================================================
+      // BLOCK OPERATIONS
+      // ===========================================================================
+      /**
+       * Get a block definition by name.
+       */
+      async getBlock(name, registryName) {
+        const registry2 = await this.loadRegistry(registryName ?? this.options.defaultRegistry);
+        return registry2.blocks[name] ?? null;
+      }
+      /**
+       * Get all blocks from a registry.
+       */
+      async getBlocks(registryName) {
+        const registry2 = await this.loadRegistry(registryName ?? this.options.defaultRegistry);
+        return registry2.blocks;
+      }
+      /**
+       * Search for blocks.
+       */
+      async searchBlocks(options, registryName) {
+        const registry2 = await this.loadRegistry(registryName ?? this.options.defaultRegistry);
+        let results = Object.values(registry2.blocks);
+        if (options.category) {
+          results = results.filter((b) => b.category === options.category);
+        }
+        if (options.query) {
+          const query = options.query.toLowerCase();
+          results = results.filter(
+            (b) => b.name.toLowerCase().includes(query) || b.displayName?.toLowerCase().includes(query) || b.description?.toLowerCase().includes(query)
+          );
+        }
+        if (options.limit && options.limit > 0) {
+          results = results.slice(0, options.limit);
+        }
+        return results;
+      }
+      /**
+       * Get block categories.
+       */
+      async getBlockCategories(registryName) {
+        const registry2 = await this.loadRegistry(registryName ?? this.options.defaultRegistry);
+        const categories = /* @__PURE__ */ new Set();
+        for (const block of Object.values(registry2.blocks)) {
+          categories.add(block.category);
+        }
+        return Array.from(categories).sort();
+      }
+      // ===========================================================================
+      // DEPENDENCY RESOLUTION
+      // ===========================================================================
+      /**
+       * Resolve all dependencies for a component.
+       */
+      async resolveComponentDependencies(name, registryName) {
+        const registry2 = registryName ?? this.options.defaultRegistry;
+        const component = await this.getComponent(name, registry2);
+        if (!component) {
+          throw new Error(`Component "${name}" not found in registry "${registry2}"`);
+        }
+        const dependencies = [];
+        for (const depName of component.dependencies.components) {
+          const resolved = await this.resolveComponentDependencies(depName, registry2);
+          dependencies.push(resolved);
+        }
+        return {
+          definition: component,
+          registry: registry2,
+          dependencies
+        };
+      }
+      /**
+       * Resolve all dependencies for a block.
+       */
+      async resolveBlockDependencies(name, registryName) {
+        const registry2 = registryName ?? this.options.defaultRegistry;
+        const block = await this.getBlock(name, registry2);
+        if (!block) {
+          throw new Error(`Block "${name}" not found in registry "${registry2}"`);
+        }
+        const dependencies = [];
+        for (const compName of block.dependencies.components) {
+          const resolved = await this.resolveComponentDependencies(compName, registry2);
+          dependencies.push(resolved);
+        }
+        for (const blockName of block.dependencies.blocks) {
+          const resolved = await this.resolveBlockDependencies(blockName, registry2);
+          dependencies.push(resolved);
+        }
+        return {
+          definition: block,
+          registry: registry2,
+          dependencies
+        };
+      }
+      /**
+       * Get flat list of all npm dependencies for resolved items.
+       */
+      getNpmDependencies(resolved) {
+        const deps = /* @__PURE__ */ new Set();
+        function collectDeps(item) {
+          const definition = item.definition;
+          if ("dependencies" in definition) {
+            for (const dep of definition.dependencies.npm) {
+              deps.add(dep);
+            }
+          }
+          for (const child of item.dependencies) {
+            collectDeps(child);
+          }
+        }
+        collectDeps(resolved);
+        return Array.from(deps).sort();
+      }
+      /**
+       * Get flat list of all file paths for resolved items.
+       */
+      getFilePaths(resolved) {
+        const paths = /* @__PURE__ */ new Set();
+        function collectPaths(item) {
+          const definition = item.definition;
+          for (const file of definition.files) {
+            paths.add(file.path);
+          }
+          for (const child of item.dependencies) {
+            collectPaths(child);
+          }
+        }
+        collectPaths(resolved);
+        return Array.from(paths).sort();
+      }
+      // ===========================================================================
+      // VERSION CHECKING
+      // ===========================================================================
+      /**
+       * Check if a component version is compatible.
+       */
+      async checkComponentVersion(name, requiredVersion, registryName) {
+        const component = await this.getComponent(name, registryName);
+        if (!component) return false;
+        return this.isVersionCompatible(component.version, requiredVersion);
+      }
+      /**
+       * Check semver version compatibility.
+       * Simple implementation - considers major.minor compatibility.
+       */
+      isVersionCompatible(actual, required) {
+        const [actualMajor, actualMinor] = actual.split(".").map(Number);
+        const [requiredMajor, requiredMinor] = required.split(".").map(Number);
+        if (actualMajor !== requiredMajor) return false;
+        return actualMinor >= requiredMinor;
+      }
+      // ===========================================================================
+      // REGISTRY INFO
+      // ===========================================================================
+      /**
+       * Get registry metadata.
+       */
+      async getRegistryInfo(registryName) {
+        const registry2 = await this.loadRegistry(registryName ?? this.options.defaultRegistry);
+        return {
+          name: registry2.name,
+          version: registry2.version,
+          description: registry2.description,
+          componentCount: Object.keys(registry2.components).length,
+          blockCount: Object.keys(registry2.blocks).length,
+          themeCount: Object.keys(registry2.themes).length
+        };
+      }
+      /**
+       * Get list of loaded registries.
+       */
+      getLoadedRegistries() {
+        return Array.from(this.registries.keys());
+      }
+    };
+    new RegistryManager();
+  }
+});
+var init_installer = __esm({
+  "src/registry/installer.ts"() {
+  }
+});
+
+// src/registry/index.ts
+var defaultRegistrySchema;
+var init_registry = __esm({
+  "src/registry/index.ts"() {
+    init_manager();
+    init_installer();
+    defaultRegistrySchema = {
+      $schema: "https://prism.omnitron.dev/registry/v1/schema.json",
+      name: "prism",
+      version: "1.0.0",
+      description: "Official Prism Design System Registry",
+      baseUrl: "https://registry.prism.omnitron.dev",
+      components: {
+        // Input Components
+        button: {
+          name: "button",
+          version: "1.0.0",
+          category: "inputs",
+          displayName: "Button",
+          description: "Primary action button with multiple variants",
+          files: [
+            { path: "Button.tsx", type: "component" },
+            { path: "Button.types.ts", type: "types" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: true,
+          docs: "https://docs.prism.omnitron.dev/components/button"
+        },
+        "icon-button": {
+          name: "icon-button",
+          version: "1.0.0",
+          category: "inputs",
+          displayName: "Icon Button",
+          description: "Compact button for icon-only actions",
+          files: [
+            { path: "IconButton.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: true
+        },
+        "text-field": {
+          name: "text-field",
+          version: "1.0.0",
+          category: "inputs",
+          displayName: "Text Field",
+          description: "Text input with label and helper text",
+          files: [
+            { path: "TextField.tsx", type: "component" },
+            { path: "TextField.types.ts", type: "types" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: true
+        },
+        select: {
+          name: "select",
+          version: "1.0.0",
+          category: "inputs",
+          displayName: "Select",
+          description: "Dropdown selection component",
+          files: [
+            { path: "Select.tsx", type: "component" },
+            { path: "Select.types.ts", type: "types" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: true
+        },
+        checkbox: {
+          name: "checkbox",
+          version: "1.0.0",
+          category: "inputs",
+          displayName: "Checkbox",
+          description: "Checkbox input for boolean values",
+          files: [
+            { path: "Checkbox.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: false
+        },
+        switch: {
+          name: "switch",
+          version: "1.0.0",
+          category: "inputs",
+          displayName: "Switch",
+          description: "Toggle switch for on/off states",
+          files: [
+            { path: "Switch.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: false
+        },
+        // Data Display
+        avatar: {
+          name: "avatar",
+          version: "1.0.0",
+          category: "data-display",
+          displayName: "Avatar",
+          description: "User avatar with image or initials",
+          files: [
+            { path: "Avatar.tsx", type: "component" },
+            { path: "AvatarGroup.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: true
+        },
+        badge: {
+          name: "badge",
+          version: "1.0.0",
+          category: "data-display",
+          displayName: "Badge",
+          description: "Badge for notifications and status",
+          files: [
+            { path: "Badge.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: true
+        },
+        chip: {
+          name: "chip",
+          version: "1.0.0",
+          category: "data-display",
+          displayName: "Chip",
+          description: "Compact element for tags and selections",
+          files: [
+            { path: "Chip.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: true
+        },
+        tooltip: {
+          name: "tooltip",
+          version: "1.0.0",
+          category: "data-display",
+          displayName: "Tooltip",
+          description: "Informative tooltip on hover",
+          files: [
+            { path: "Tooltip.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: false
+        },
+        // Feedback
+        alert: {
+          name: "alert",
+          version: "1.0.0",
+          category: "feedback",
+          displayName: "Alert",
+          description: "Alert messages with severity levels",
+          files: [
+            { path: "Alert.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: true
+        },
+        snackbar: {
+          name: "snackbar",
+          version: "1.0.0",
+          category: "feedback",
+          displayName: "Snackbar",
+          description: "Brief notification messages",
+          files: [
+            { path: "Snackbar.tsx", type: "component" },
+            { path: "SnackbarProvider.tsx", type: "component" },
+            { path: "useSnackbar.ts", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material", "notistack"],
+            components: []
+          },
+          hasVariants: false
+        },
+        dialog: {
+          name: "dialog",
+          version: "1.0.0",
+          category: "feedback",
+          displayName: "Dialog",
+          description: "Modal dialog with actions",
+          files: [
+            { path: "Dialog.tsx", type: "component" },
+            { path: "ConfirmDialog.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: ["button"]
+          },
+          hasVariants: false
+        },
+        progress: {
+          name: "progress",
+          version: "1.0.0",
+          category: "feedback",
+          displayName: "Progress",
+          description: "Progress indicators (linear and circular)",
+          files: [
+            { path: "LinearProgress.tsx", type: "component" },
+            { path: "CircularProgress.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: false
+        },
+        // Surfaces
+        card: {
+          name: "card",
+          version: "1.0.0",
+          category: "surfaces",
+          displayName: "Card",
+          description: "Content card with header, content, and actions",
+          files: [
+            { path: "Card.tsx", type: "component" },
+            { path: "Card.types.ts", type: "types" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: true
+        },
+        paper: {
+          name: "paper",
+          version: "1.0.0",
+          category: "surfaces",
+          displayName: "Paper",
+          description: "Basic surface with elevation",
+          files: [
+            { path: "Paper.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: false
+        },
+        accordion: {
+          name: "accordion",
+          version: "1.0.0",
+          category: "surfaces",
+          displayName: "Accordion",
+          description: "Expandable content panels",
+          files: [
+            { path: "Accordion.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: false
+        },
+        // Navigation
+        tabs: {
+          name: "tabs",
+          version: "1.0.0",
+          category: "navigation",
+          displayName: "Tabs",
+          description: "Tabbed navigation component",
+          files: [
+            { path: "Tabs.tsx", type: "component" },
+            { path: "TabPanel.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: true
+        },
+        breadcrumbs: {
+          name: "breadcrumbs",
+          version: "1.0.0",
+          category: "navigation",
+          displayName: "Breadcrumbs",
+          description: "Navigation breadcrumb trail",
+          files: [
+            { path: "Breadcrumbs.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: false
+        },
+        menu: {
+          name: "menu",
+          version: "1.0.0",
+          category: "navigation",
+          displayName: "Menu",
+          description: "Dropdown menu for actions",
+          files: [
+            { path: "Menu.tsx", type: "component" },
+            { path: "MenuItem.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: false
+        },
+        // Layout
+        stack: {
+          name: "stack",
+          version: "1.0.0",
+          category: "layout",
+          displayName: "Stack",
+          description: "Vertical/horizontal flex layout",
+          files: [
+            { path: "Stack.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: false
+        },
+        grid: {
+          name: "grid",
+          version: "1.0.0",
+          category: "layout",
+          displayName: "Grid",
+          description: "Responsive grid layout",
+          files: [
+            { path: "Grid.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: false
+        },
+        container: {
+          name: "container",
+          version: "1.0.0",
+          category: "layout",
+          displayName: "Container",
+          description: "Centered content container",
+          files: [
+            { path: "Container.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: false
+        },
+        divider: {
+          name: "divider",
+          version: "1.0.0",
+          category: "layout",
+          displayName: "Divider",
+          description: "Visual separator",
+          files: [
+            { path: "Divider.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: false
+        },
+        // Data
+        "data-table": {
+          name: "data-table",
+          version: "1.0.0",
+          category: "data",
+          displayName: "Data Table",
+          description: "Full-featured data table with sorting, filtering, pagination",
+          files: [
+            { path: "DataTable.tsx", type: "component" },
+            { path: "DataTable.types.ts", type: "types" },
+            { path: "DataTableToolbar.tsx", type: "component" },
+            { path: "DataTablePagination.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material", "@tanstack/react-table"],
+            components: ["button", "text-field", "select", "checkbox", "menu"]
+          },
+          hasVariants: true,
+          docs: "https://docs.prism.omnitron.dev/components/data-table"
+        },
+        table: {
+          name: "table",
+          version: "1.0.0",
+          category: "data",
+          displayName: "Table",
+          description: "Basic table component",
+          files: [
+            { path: "Table.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: false
+        },
+        list: {
+          name: "list",
+          version: "1.0.0",
+          category: "data",
+          displayName: "List",
+          description: "Vertical list of items",
+          files: [
+            { path: "List.tsx", type: "component" },
+            { path: "ListItem.tsx", type: "component" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material"],
+            components: []
+          },
+          hasVariants: false
+        }
+      },
+      blocks: {
+        // Dashboard blocks
+        "dashboard-layout": {
+          name: "dashboard-layout",
+          version: "1.0.0",
+          category: "layouts",
+          displayName: "Dashboard Layout",
+          description: "Complete dashboard layout with sidebar and header",
+          files: [
+            { path: "DashboardLayout.tsx", type: "component" },
+            { path: "DashboardLayout.types.ts", type: "type" },
+            { path: "Sidebar.tsx", type: "component" },
+            { path: "Header.tsx", type: "component" },
+            { path: "NavSection.tsx", type: "component" },
+            { path: "NavItem.tsx", type: "component" },
+            { path: "useDashboard.ts", type: "hook" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material", "framer-motion"],
+            components: ["avatar", "menu", "icon-button", "tooltip"],
+            blocks: []
+          },
+          defaultConfig: {
+            sidebarWidth: 280,
+            headerHeight: 64,
+            collapsedWidth: 72
+          },
+          docs: "https://docs.prism.omnitron.dev/blocks/dashboard-layout"
+        },
+        "auth-forms": {
+          name: "auth-forms",
+          version: "1.0.0",
+          category: "auth",
+          displayName: "Authentication Forms",
+          description: "Login, register, forgot password, and verify forms",
+          files: [
+            { path: "LoginForm.tsx", type: "component" },
+            { path: "RegisterForm.tsx", type: "component" },
+            { path: "ForgotPasswordForm.tsx", type: "component" },
+            { path: "VerifyCodeForm.tsx", type: "component" },
+            { path: "auth.schema.ts", type: "schema" },
+            { path: "useAuthForm.ts", type: "hook" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material", "react-hook-form", "@hookform/resolvers", "zod"],
+            components: ["button", "text-field", "checkbox", "alert"],
+            blocks: []
+          },
+          defaultConfig: {
+            showSocialLogin: true,
+            showRememberMe: true
+          }
+        },
+        "settings-panel": {
+          name: "settings-panel",
+          version: "1.0.0",
+          category: "settings",
+          displayName: "Settings Panel",
+          description: "Theme settings panel with live preview",
+          files: [
+            { path: "SettingsPanel.tsx", type: "component" },
+            { path: "SettingsDrawer.tsx", type: "component" },
+            { path: "ThemePreview.tsx", type: "component" },
+            { path: "useSettings.ts", type: "hook" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material", "framer-motion"],
+            components: ["button", "switch", "select", "icon-button"],
+            blocks: []
+          },
+          defaultConfig: {
+            position: "right"
+          }
+        },
+        "user-profile": {
+          name: "user-profile",
+          version: "1.0.0",
+          category: "data",
+          displayName: "User Profile",
+          description: "User profile page with avatar, info, and settings",
+          files: [
+            { path: "ProfilePage.tsx", type: "component" },
+            { path: "ProfileHeader.tsx", type: "component" },
+            { path: "ProfileTabs.tsx", type: "component" },
+            { path: "AccountTab.tsx", type: "component" },
+            { path: "SecurityTab.tsx", type: "component" },
+            { path: "NotificationsTab.tsx", type: "component" },
+            { path: "useProfile.ts", type: "hook" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material", "react-hook-form"],
+            components: ["avatar", "button", "tabs", "card", "text-field", "switch"],
+            blocks: []
+          },
+          defaultConfig: {}
+        },
+        "data-grid": {
+          name: "data-grid",
+          version: "1.0.0",
+          category: "data",
+          displayName: "Data Grid",
+          description: "Advanced data grid with server-side features",
+          files: [
+            { path: "DataGrid.tsx", type: "component" },
+            { path: "DataGrid.types.ts", type: "type" },
+            { path: "GridToolbar.tsx", type: "component" },
+            { path: "GridFilters.tsx", type: "component" },
+            { path: "GridExport.tsx", type: "component" },
+            { path: "useDataGrid.ts", type: "hook" },
+            { path: "index.ts", type: "barrel" }
+          ],
+          dependencies: {
+            npm: ["@mui/material", "@tanstack/react-table", "@tanstack/react-virtual"],
+            components: ["button", "text-field", "select", "checkbox", "menu", "chip"],
+            blocks: []
+          },
+          defaultConfig: {
+            pageSize: 25,
+            enableColumnResize: true,
+            enableColumnReorder: true
+          }
+        }
+      },
+      themes: {}
+    };
+  }
+});
+
+// src/cli/commands/add.ts
+var add_exports = {};
+__export(add_exports, {
+  addCommand: () => addCommand,
+  generateFileContent: () => generateFileContent,
+  toPascalCase: () => toPascalCase
+});
+function addCommand() {
+  const command = new Command("add");
+  command.description("Add components or blocks to your project").argument("[items...]", "Components or blocks to add").option("-y, --yes", "Skip confirmation prompts").option("-o, --overwrite", "Overwrite existing files").option("-a, --all", "Add all available components").option("-c, --cwd <path>", "Working directory", process.cwd()).option("-p, --path <path>", "Custom output path").option("-i, --install", "Auto-install npm dependencies").action(async (items, options) => {
+    await runAdd(items, options);
+  });
+  return command;
+}
+async function runAdd(items, options) {
+  const cwd = options.cwd || process.cwd();
+  const config = await loadConfig(cwd);
+  if (!config) {
+    log.error("No prism.config.json found. Run `prism init` first.");
+    process.exit(1);
+  }
+  let itemsToAdd = items;
+  if (options.all) {
+    itemsToAdd = [
+      ...Object.keys(defaultRegistrySchema.components),
+      ...Object.keys(defaultRegistrySchema.blocks).map((b) => `block:${b}`)
+    ];
+  }
+  if (itemsToAdd.length === 0) {
+    log.error("No items specified. Use `prism add <component>` or `prism add --all`");
+    log.info("Run `prism list` to see available components.");
+    process.exit(1);
+  }
+  console.log("");
+  log.info(`Adding ${itemsToAdd.length} item(s)...`);
+  console.log("");
+  const results = [];
+  const allNpmDeps = /* @__PURE__ */ new Set();
+  for (const item of itemsToAdd) {
+    try {
+      const result = await addItem(item, config, options);
+      results.push(result);
+      if (result.npmDeps) {
+        for (const dep of result.npmDeps) {
+          allNpmDeps.add(dep);
+        }
+      }
+    } catch (error) {
+      results.push({
+        name: item,
+        success: false,
+        error: error.message
+      });
+    }
+  }
+  console.log("");
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.filter((r) => !r.success).length;
+  if (successCount > 0) {
+    log.success(`Added ${successCount} item(s) successfully.`);
+  }
+  if (failCount > 0) {
+    log.error(`Failed to add ${failCount} item(s).`);
+    for (const result of results.filter((r) => !r.success)) {
+      log.muted(`  - ${result.name}: ${result.error}`);
+    }
+  }
+  if (allNpmDeps.size > 0) {
+    console.log("");
+    log.info("Required npm dependencies:");
+    const depsArray = Array.from(allNpmDeps).sort();
+    for (const dep of depsArray) {
+      log.muted(`  - ${dep}`);
+    }
+    console.log("");
+    log.info("Install with:");
+    log.muted(`  npm install ${depsArray.join(" ")}`);
+    log.muted(`  # or`);
+    log.muted(`  pnpm add ${depsArray.join(" ")}`);
+    if ((options.install || options.yes) && allNpmDeps.size > 0) {
+      const pm = detectPackageManager(cwd);
+      const installCmd = pm === "pnpm" ? "pnpm add" : pm === "yarn" ? "yarn add" : "npm install";
+      log.info(`Installing dependencies with ${pm}...`);
+      try {
+        const { execSync } = await import('child_process');
+        execSync(`${installCmd} ${depsArray.join(" ")}`, {
+          cwd,
+          stdio: "inherit"
+        });
+        log.success("Dependencies installed successfully.");
+      } catch {
+        log.warning("Auto-install failed. Please install dependencies manually.");
+      }
+    }
+  }
+  console.log("");
+}
+function detectPackageManager(cwd) {
+  if (fs6.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs6.existsSync(path.join(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+async function addItem(item, config, options) {
+  const isBlock = item.startsWith("block:");
+  const itemName = isBlock ? item.slice(6) : item;
+  const registry2 = isBlock ? defaultRegistrySchema.blocks : defaultRegistrySchema.components;
+  const definition = registry2[itemName];
+  if (!definition) {
+    return {
+      name: item,
+      success: false,
+      error: `Not found in registry. Run 'prism list' to see available items.`
+    };
+  }
+  const outputPath = options.path ? path.join(config.rootDir, options.path, itemName) : isBlock ? getBlockPath(itemName, config) : getComponentPath(itemName, config);
+  if (fs6.existsSync(outputPath) && !options.overwrite) {
+    return {
+      name: item,
+      success: false,
+      error: `Already exists at ${path.relative(config.rootDir, outputPath)}. Use --overwrite to replace.`
+    };
+  }
+  await fs6.promises.mkdir(outputPath, { recursive: true });
+  for (const file of definition.files) {
+    const filePath = path.join(outputPath, file.path);
+    const content = generateFileContent(itemName, file.path, file.type, definition, isBlock);
+    await fs6.promises.writeFile(filePath, content, "utf-8");
+  }
+  log.success(`Added ${itemName} \u2192 ${path.relative(config.rootDir, outputPath)}/`);
+  await updateLockfile(config.rootDir, itemName, definition.version, isBlock);
+  const npmDeps = [];
+  if ("dependencies" in definition && definition.dependencies?.npm) {
+    npmDeps.push(...definition.dependencies.npm);
+  }
+  return { name: item, success: true, npmDeps };
+}
+async function updateLockfile(rootDir, name, version, isBlock) {
+  const lockfilePath = path.join(rootDir, "prism.lock.json");
+  let lockfile = {
+    version: "1",
+    components: {},
+    blocks: {}
+  };
+  if (fs6.existsSync(lockfilePath)) {
+    try {
+      lockfile = JSON.parse(await fs6.promises.readFile(lockfilePath, "utf-8"));
+    } catch {
+    }
+  }
+  const entry = {
+    name,
+    version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (isBlock) {
+    lockfile.blocks[name] = entry;
+  } else {
+    lockfile.components[name] = entry;
+  }
+  await fs6.promises.writeFile(lockfilePath, JSON.stringify(lockfile, null, 2) + "\n", "utf-8");
+}
+function toPascalCase(name) {
+  return name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function toCamelCase(name) {
+  const pascal = toPascalCase(name);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function generateFileContent(name, fileName, fileType, definition, isBlock) {
+  const pascalName = toPascalCase(name);
+  const camelName = toCamelCase(name);
+  if (fileName === "index.ts") {
+    return generateBarrelExport(definition, pascalName);
+  }
+  if (fileType === "types" || fileName.endsWith(".types.ts")) {
+    return generateTypeDefinitions(name, pascalName);
+  }
+  if (fileType === "hook" || fileName.startsWith("use")) {
+    const hookName = fileName.replace(".ts", "");
+    return generateHook(hookName, pascalName, definition, isBlock);
+  }
+  if (fileType === "schema" || fileName.endsWith(".schema.ts")) {
+    return generateSchema(name, pascalName, definition);
+  }
+  return generateComponent(name, pascalName, camelName, fileName, definition, isBlock);
+}
+function generateBarrelExport(definition, pascalName) {
+  const exports$1 = [];
+  for (const file of definition.files) {
+    if (file.path === "index.ts") continue;
+    const moduleName = file.path.replace(/\.tsx?$/, ".js");
+    if (file.type === "types" || file.path.endsWith(".types.ts")) {
+      exports$1.push(`export type * from './${moduleName}';`);
+    } else {
+      exports$1.push(`export * from './${moduleName}';`);
+    }
+  }
+  return `/**
+ * ${definition.displayName || pascalName}
+ *
+ * ${definition.description || ""}
+ *
+ * @module @omnitron-dev/prism/components/${definition.name}
+ */
+
+${exports$1.join("\n")}
+`;
+}
+function generateTypeDefinitions(name, pascalName, definition) {
+  const muiComponent = getMuiComponent(name);
+  return `/**
+ * ${pascalName} Type Definitions
+ *
+ * @module @omnitron-dev/prism/components/${name}
+ */
+
+import type { ${muiComponent}Props as Mui${muiComponent}Props } from '@mui/material/${muiComponent}';
+
+/**
+ * Props for the ${pascalName} component.
+ * Extends MUI ${muiComponent} with Prism-specific options.
+ */
+export interface ${pascalName}Props extends Mui${muiComponent}Props {
+  /**
+   * Additional CSS class name.
+   */
+  className?: string;
+}
+
+/**
+ * Ref type for ${pascalName} component.
+ */
+export type ${pascalName}Ref = HTMLDivElement;
+`;
+}
+function generateHook(hookName, pascalName, definition, isBlock) {
+  const camelHook = toCamelCase(hookName);
+  if (isBlock) {
+    return generateBlockHook(hookName, pascalName, definition);
+  }
+  return `/**
+ * ${hookName} Hook
+ *
+ * Custom hook for ${definition.displayName || pascalName} component logic.
+ *
+ * @module @omnitron-dev/prism/components/${definition.name}
+ */
+
+import { useState, useCallback, useMemo } from 'react';
+
+/**
+ * Options for ${camelHook} hook.
+ */
+export interface ${toPascalCase(hookName)}Options {
+  /**
+   * Initial state value.
+   */
+  initialValue?: boolean;
+}
+
+/**
+ * Return type for ${camelHook} hook.
+ */
+export interface ${toPascalCase(hookName)}Return {
+  /**
+   * Current state value.
+   */
+  value: boolean;
+  /**
+   * Set value to true.
+   */
+  onOpen: () => void;
+  /**
+   * Set value to false.
+   */
+  onClose: () => void;
+  /**
+   * Toggle the value.
+   */
+  onToggle: () => void;
+}
+
+/**
+ * Hook for managing ${definition.displayName || pascalName} state.
+ *
+ * @param options - Hook options
+ * @returns State and handlers
+ *
+ * @example
+ * \`\`\`tsx
+ * function Example() {
+ *   const { value, onOpen, onClose, onToggle } = ${camelHook}();
+ *
+ *   return (
+ *     <button onClick={onToggle}>
+ *       {value ? 'Open' : 'Closed'}
+ *     </button>
+ *   );
+ * }
+ * \`\`\`
+ */
+export function ${camelHook}(options: ${toPascalCase(hookName)}Options = {}): ${toPascalCase(hookName)}Return {
+  const { initialValue = false } = options;
+
+  const [value, setValue] = useState(initialValue);
+
+  const onOpen = useCallback(() => setValue(true), []);
+  const onClose = useCallback(() => setValue(false), []);
+  const onToggle = useCallback(() => setValue((prev) => !prev), []);
+
+  return useMemo(
+    () => ({ value, onOpen, onClose, onToggle }),
+    [value, onOpen, onClose, onToggle]
+  );
+}
+`;
+}
+function generateBlockHook(hookName, pascalName, definition) {
+  const camelHook = toCamelCase(hookName);
+  return `/**
+ * ${hookName} Hook
+ *
+ * State management hook for ${definition.displayName || pascalName} block.
+ *
+ * @module @omnitron-dev/prism/blocks/${definition.name}
+ */
+
+import { useState, useCallback, useMemo, useContext, createContext } from 'react';
+import type { ReactNode } from 'react';
+
+// =============================================================================
+// TYPES
+// =============================================================================
+
+/**
+ * State for ${pascalName} block.
+ */
+export interface ${pascalName}State {
+  /**
+   * Whether the sidebar/panel is open.
+   */
+  isOpen: boolean;
+  /**
+   * Whether the sidebar/panel is collapsed.
+   */
+  isCollapsed: boolean;
+}
+
+/**
+ * Actions for ${pascalName} block.
+ */
+export interface ${pascalName}Actions {
+  /**
+   * Open the sidebar/panel.
+   */
+  open: () => void;
+  /**
+   * Close the sidebar/panel.
+   */
+  close: () => void;
+  /**
+   * Toggle open state.
+   */
+  toggle: () => void;
+  /**
+   * Collapse the sidebar.
+   */
+  collapse: () => void;
+  /**
+   * Expand the sidebar.
+   */
+  expand: () => void;
+  /**
+   * Toggle collapsed state.
+   */
+  toggleCollapse: () => void;
+}
+
+/**
+ * Context value for ${pascalName}.
+ */
+export interface ${pascalName}ContextValue extends ${pascalName}State, ${pascalName}Actions {}
+
+/**
+ * Options for ${camelHook} hook.
+ */
+export interface ${toPascalCase(hookName)}Options {
+  /**
+   * Initial open state.
+   */
+  defaultOpen?: boolean;
+  /**
+   * Initial collapsed state.
+   */
+  defaultCollapsed?: boolean;
+}
+
+// =============================================================================
+// CONTEXT
+// =============================================================================
+
+const ${pascalName}Context = createContext<${pascalName}ContextValue | null>(null);
+
+/**
+ * Provider props.
+ */
+export interface ${pascalName}ProviderProps extends ${toPascalCase(hookName)}Options {
+  children: ReactNode;
+}
+
+/**
+ * Provider component for ${pascalName} context.
+ */
+export function ${pascalName}Provider({
+  children,
+  defaultOpen = true,
+  defaultCollapsed = false,
+}: ${pascalName}ProviderProps) {
+  const value = ${camelHook}({ defaultOpen, defaultCollapsed });
+
+  return (
+    <${pascalName}Context.Provider value={value}>
+      {children}
+    </${pascalName}Context.Provider>
+  );
+}
+
+// =============================================================================
+// HOOK
+// =============================================================================
+
+/**
+ * Hook for managing ${definition.displayName || pascalName} state.
+ *
+ * @param options - Hook options
+ * @returns State and actions
+ *
+ * @example
+ * \`\`\`tsx
+ * function ${pascalName}() {
+ *   const { isOpen, isCollapsed, toggle, toggleCollapse } = ${camelHook}();
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={toggle}>Toggle Open</button>
+ *       <button onClick={toggleCollapse}>Toggle Collapse</button>
+ *     </div>
+ *   );
+ * }
+ * \`\`\`
+ */
+export function ${camelHook}(
+  options: ${toPascalCase(hookName)}Options = {}
+): ${pascalName}ContextValue {
+  const context = useContext(${pascalName}Context);
+
+  const { defaultOpen = true, defaultCollapsed = false } = options;
+
+  const [isOpen, setIsOpen] = useState(context?.isOpen ?? defaultOpen);
+  const [isCollapsed, setIsCollapsed] = useState(context?.isCollapsed ?? defaultCollapsed);
+
+  const open = useCallback(() => setIsOpen(true), []);
+  const close = useCallback(() => setIsOpen(false), []);
+  const toggle = useCallback(() => setIsOpen((prev) => !prev), []);
+
+  const collapse = useCallback(() => setIsCollapsed(true), []);
+  const expand = useCallback(() => setIsCollapsed(false), []);
+  const toggleCollapse = useCallback(() => setIsCollapsed((prev) => !prev), []);
+
+  return useMemo(
+    () => ({
+      isOpen,
+      isCollapsed,
+      open,
+      close,
+      toggle,
+      collapse,
+      expand,
+      toggleCollapse,
+    }),
+    [isOpen, isCollapsed, open, close, toggle, collapse, expand, toggleCollapse]
+  );
+}
+
+/**
+ * Hook to consume ${pascalName} context.
+ * Must be used within a ${pascalName}Provider.
+ */
+export function use${pascalName}Context(): ${pascalName}ContextValue {
+  const context = useContext(${pascalName}Context);
+
+  if (!context) {
+    throw new Error('use${pascalName}Context must be used within a ${pascalName}Provider');
+  }
+
+  return context;
+}
+`;
+}
+function generateSchema(name, pascalName, definition) {
+  return `/**
+ * ${pascalName} Schema
+ *
+ * Zod validation schemas for ${definition.displayName || pascalName} forms.
+ *
+ * @module @omnitron-dev/prism/blocks/${definition.name}
+ */
+
+import { z } from 'zod';
+
+/**
+ * Login form schema.
+ */
+export const loginSchema = z.object({
+  email: z
+    .string()
+    .min(1, 'Email is required')
+    .email('Invalid email address'),
+  password: z
+    .string()
+    .min(1, 'Password is required')
+    .min(8, 'Password must be at least 8 characters'),
+  rememberMe: z.boolean().optional(),
+});
+
+/**
+ * Login form values type.
+ */
+export type LoginFormValues = z.infer<typeof loginSchema>;
+
+/**
+ * Register form schema.
+ */
+export const registerSchema = z
+  .object({
+    firstName: z.string().min(1, 'First name is required'),
+    lastName: z.string().min(1, 'Last name is required'),
+    email: z
+      .string()
+      .min(1, 'Email is required')
+      .email('Invalid email address'),
+    password: z
+      .string()
+      .min(1, 'Password is required')
+      .min(8, 'Password must be at least 8 characters'),
+    confirmPassword: z.string().min(1, 'Please confirm your password'),
+    acceptTerms: z.literal(true, {
+      errorMap: () => ({ message: 'You must accept the terms' }),
+    }),
+  })
+  .refine((data) => data.password === data.confirmPassword, {
+    message: 'Passwords do not match',
+    path: ['confirmPassword'],
+  });
+
+/**
+ * Register form values type.
+ */
+export type RegisterFormValues = z.infer<typeof registerSchema>;
+
+/**
+ * Forgot password form schema.
+ */
+export const forgotPasswordSchema = z.object({
+  email: z
+    .string()
+    .min(1, 'Email is required')
+    .email('Invalid email address'),
+});
+
+/**
+ * Forgot password form values type.
+ */
+export type ForgotPasswordFormValues = z.infer<typeof forgotPasswordSchema>;
+
+/**
+ * Verify code form schema.
+ */
+export const verifyCodeSchema = z.object({
+  code: z
+    .string()
+    .min(1, 'Code is required')
+    .length(6, 'Code must be 6 digits'),
+});
+
+/**
+ * Verify code form values type.
+ */
+export type VerifyCodeFormValues = z.infer<typeof verifyCodeSchema>;
+`;
+}
+function generateComponent(name, pascalName, camelName, fileName, definition, isBlock) {
+  const componentName = fileName.replace(/\.tsx$/, "");
+  const componentPascal = toPascalCase(componentName.replace(pascalName, "")) || pascalName;
+  const muiComponent = getMuiComponent(name);
+  if (isBlock) {
+    return generateBlockComponent(name, componentName, componentPascal, definition);
+  }
+  return `'use client';
+
+/**
+ * ${componentPascal} Component
+ *
+ * ${definition.description || ""}
+ *
+ * @module @omnitron-dev/prism/components/${definition.name}
+ * @see https://mui.com/material-ui/react-${name}/
+ */
+
+import { forwardRef } from 'react';
+import Mui${muiComponent} from '@mui/material/${muiComponent}';
+import type { ${muiComponent}Props as Mui${muiComponent}Props } from '@mui/material/${muiComponent}';
+import { clsx } from 'clsx';
+
+/**
+ * Props for the ${componentPascal} component.
+ */
+export interface ${componentPascal}Props extends Mui${muiComponent}Props {
+  /**
+   * Additional CSS class name.
+   */
+  className?: string;
+}
+
+/**
+ * ${definition.displayName || componentPascal} component.
+ *
+ * A wrapper around MUI ${muiComponent} with Prism design system styling.
+ *
+ * @example
+ * \`\`\`tsx
+ * <${componentPascal} variant="contained" color="primary">
+ *   Click me
+ * </${componentPascal}>
+ * \`\`\`
+ */
+export const ${componentPascal} = forwardRef<HTMLButtonElement, ${componentPascal}Props>(
+  function ${componentPascal}({ className, ...props }, ref) {
+    return (
+      <Mui${muiComponent}
+        ref={ref}
+        className={clsx('prism-${name}', className)}
+        {...props}
+      />
+    );
+  }
+);
+
+${componentPascal}.displayName = '${componentPascal}';
+`;
+}
+function generateBlockComponent(name, componentName, componentPascal, definition) {
+  return `'use client';
+
+/**
+ * ${componentPascal} Component
+ *
+ * ${definition.description || ""}
+ *
+ * @module @omnitron-dev/prism/blocks/${definition.name}
+ */
+
+import { forwardRef } from 'react';
+import type { ReactNode } from 'react';
+import Box from '@mui/material/Box';
+import type { BoxProps } from '@mui/material/Box';
+import { styled } from '@mui/material/styles';
+import { clsx } from 'clsx';
+
+/**
+ * Props for the ${componentPascal} component.
+ */
+export interface ${componentPascal}Props extends Omit<BoxProps, 'children'> {
+  /**
+   * Content to render inside the component.
+   */
+  children?: ReactNode;
+  /**
+   * Additional CSS class name.
+   */
+  className?: string;
+}
+
+/**
+ * Styled root component.
+ */
+const ${componentPascal}Root = styled(Box)(({ theme }) => ({
+  display: 'flex',
+  flexDirection: 'column',
+  minHeight: '100vh',
+  backgroundColor: theme.palette.background.default,
+}));
+
+/**
+ * ${definition.displayName || componentPascal} component.
+ *
+ * @example
+ * \`\`\`tsx
+ * <${componentPascal}>
+ *   <Header />
+ *   <Sidebar />
+ *   <Main />
+ * </${componentPascal}>
+ * \`\`\`
+ */
+export const ${componentPascal} = forwardRef<HTMLDivElement, ${componentPascal}Props>(
+  function ${componentPascal}({ className, children, ...props }, ref) {
+    return (
+      <${componentPascal}Root
+        ref={ref}
+        className={clsx('prism-${name}', className)}
+        {...props}
+      >
+        {children}
+      </${componentPascal}Root>
+    );
+  }
+);
+
+${componentPascal}.displayName = '${componentPascal}';
+`;
+}
+function getMuiComponent(name) {
+  const mapping = {
+    button: "Button",
+    "icon-button": "IconButton",
+    "text-field": "TextField",
+    select: "Select",
+    checkbox: "Checkbox",
+    switch: "Switch",
+    avatar: "Avatar",
+    badge: "Badge",
+    chip: "Chip",
+    tooltip: "Tooltip",
+    alert: "Alert",
+    snackbar: "Snackbar",
+    dialog: "Dialog",
+    progress: "CircularProgress",
+    card: "Card",
+    paper: "Paper",
+    accordion: "Accordion",
+    tabs: "Tabs",
+    breadcrumbs: "Breadcrumbs",
+    menu: "Menu",
+    stack: "Stack",
+    grid: "Grid",
+    container: "Container",
+    divider: "Divider",
+    "data-table": "Table",
+    table: "Table",
+    list: "List"
+  };
+  return mapping[name] || toPascalCase(name);
+}
+var init_add = __esm({
+  "src/cli/commands/add.ts"() {
+    init_constants();
+    init_config();
+    init_registry();
+  }
+});
+
+// src/cli/index.ts
+init_add();
+
+// src/cli/commands/init.ts
+init_constants();
+init_config();
+async function prompt(question, defaultValue) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve3) => {
+    const displayQuestion = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
+    rl.question(displayQuestion, (answer) => {
+      rl.close();
+      resolve3(answer.trim() || defaultValue || "");
+    });
+  });
+}
+async function confirm(question, defaultValue = true) {
+  const hint = defaultValue ? "(Y/n)" : "(y/N)";
+  const answer = await prompt(`${question} ${hint}`);
+  if (!answer) {
+    return defaultValue;
+  }
+  return ["y", "yes", "\u0434\u0430"].includes(answer.toLowerCase());
+}
+function initCommand() {
+  const command = new Command("init");
+  command.description("Initialize Prism in your project").option("-y, --yes", "Skip prompts and use defaults").option("-d, --defaults", "Use default configuration").option("-c, --cwd <path>", "Working directory", process.cwd()).action(async (options) => {
+    await runInit(options);
+  });
+  return command;
+}
+async function runInit(options) {
+  const cwd = options.cwd || process.cwd();
+  console.log("");
+  log.info("Initializing Prism...");
+  console.log("");
+  const existingConfig = findConfigFile(cwd);
+  if (existingConfig) {
+    log.warning(`Config already exists at ${existingConfig}`);
+    const overwrite = options.yes || await confirm("Overwrite existing configuration?", false);
+    if (!overwrite) {
+      log.info("Initialization cancelled.");
+      return;
+    }
+  }
+  let config;
+  if (options.yes || options.defaults) {
+    config = { ...DEFAULT_CONFIG };
+  } else {
+    config = await interactiveInit(cwd);
+  }
+  const dirs = [
+    path.join(cwd, DEFAULT_COMPONENTS_DIR),
+    path.join(cwd, DEFAULT_BLOCKS_DIR),
+    path.join(cwd, DEFAULT_HOOKS_DIR),
+    path.join(cwd, DEFAULT_UTILS_DIR)
+  ];
+  for (const dir of dirs) {
+    if (!fs6.existsSync(dir)) {
+      await fs6.promises.mkdir(dir, { recursive: true });
+      log.success(`Created ${path.relative(cwd, dir)}/`);
+    }
+  }
+  const configPath = path.join(cwd, CONFIG_FILE_NAME);
+  await saveConfig(config, configPath);
+  log.success(`Created ${CONFIG_FILE_NAME}`);
+  console.log("");
+  log.success("Prism initialized successfully!");
+  console.log("");
+  log.info("Next steps:");
+  console.log("  1. Run `prism add button` to add your first component");
+  console.log("  2. Run `prism list` to see available components");
+  console.log("  3. Visit https://prism.omnitron.dev/docs for documentation");
+  console.log("");
+}
+async function interactiveInit(cwd) {
+  console.log("This will guide you through configuring Prism for your project.\n");
+  const styleAnswer = await prompt("Which style would you like to use? (default/new-york)", "default");
+  const style = styleAnswer === "new-york" ? "new-york" : "default";
+  const componentsAlias = await prompt("Where should components be installed?", "@/components/ui");
+  const blocksAlias = await prompt("Where should blocks be installed?", "@/blocks");
+  const hooksAlias = await prompt("Where should hooks be installed?", "@/hooks");
+  const utilsAlias = await prompt("Where should utils be installed?", "@/utils");
+  const tailwindConfigPath = path.join(cwd, "tailwind.config.js");
+  const tailwindTsConfigPath = path.join(cwd, "tailwind.config.ts");
+  const hasTailwind = fs6.existsSync(tailwindConfigPath) || fs6.existsSync(tailwindTsConfigPath);
+  let tailwindConfig;
+  if (hasTailwind) {
+    const useTailwind = await confirm("Tailwind CSS detected. Configure CSS variables?", true);
+    if (useTailwind) {
+      const cssFile = await prompt("Where is your global CSS file?", "src/index.css");
+      const baseColor = await prompt("What base color would you like?", "slate");
+      tailwindConfig = {
+        config: fs6.existsSync(tailwindTsConfigPath) ? "tailwind.config.ts" : "tailwind.config.js",
+        css: cssFile,
+        baseColor,
+        cssVariables: true
+      };
+    }
+  }
+  return {
+    $schema: "https://prism.omnitron.dev/schema.json",
+    style,
+    tailwind: tailwindConfig,
+    aliases: {
+      components: componentsAlias,
+      blocks: blocksAlias,
+      hooks: hooksAlias,
+      utils: utilsAlias
+    },
+    registries: DEFAULT_CONFIG.registries
+  };
+}
+
+// src/cli/commands/list.ts
+init_constants();
+init_registry();
+function listCommand() {
+  const command = new Command("list");
+  command.description("List available components and blocks").option("-c, --components", "List only components").option("-b, --blocks", "List only blocks").option("--category <category>", "Filter by category").option("--json", "Output as JSON").action(async (options) => {
+    await runList(options);
+  });
+  return command;
+}
+async function runList(options) {
+  const showComponents = options.components || !options.components && !options.blocks;
+  const showBlocks = options.blocks || !options.components && !options.blocks;
+  if (options.json) {
+    const output = {
+      ...showComponents && { components: defaultRegistrySchema.components },
+      ...showBlocks && { blocks: defaultRegistrySchema.blocks }
+    };
+    console.log(JSON.stringify(output, null, 2));
+    return;
+  }
+  console.log("");
+  if (showComponents) {
+    log.info("Available Components:");
+    console.log("");
+    listItems(defaultRegistrySchema.components, options.category, COMPONENT_CATEGORIES);
+  }
+  if (showBlocks) {
+    if (showComponents) console.log("");
+    log.info("Available Blocks:");
+    console.log("");
+    listItems(defaultRegistrySchema.blocks, options.category, BLOCK_CATEGORIES);
+  }
+  console.log("");
+  log.muted("Use `prism add <name>` to add a component to your project.");
+  log.muted("Use `prism add block:<name>` to add a block to your project.");
+  console.log("");
+}
+function listItems(items, filterCategory, categoryOrder) {
+  const byCategory = {};
+  for (const item of Object.values(items)) {
+    if (filterCategory && item.category !== filterCategory) {
+      continue;
+    }
+    if (!byCategory[item.category]) {
+      byCategory[item.category] = [];
+    }
+    byCategory[item.category].push(item);
+  }
+  const sortedCategories = Object.keys(byCategory).sort((a, b) => {
+    const aIndex = categoryOrder.indexOf(a);
+    const bIndex = categoryOrder.indexOf(b);
+    if (aIndex === -1 && bIndex === -1) return a.localeCompare(b);
+    if (aIndex === -1) return 1;
+    if (bIndex === -1) return -1;
+    return aIndex - bIndex;
+  });
+  for (const category of sortedCategories) {
+    const categoryItems = byCategory[category];
+    const categoryTitle = category.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+    console.log(`  ${COLORS.primary}${categoryTitle}${COLORS.reset}`);
+    for (const item of categoryItems.sort((a, b) => a.name.localeCompare(b.name))) {
+      const displayName = item.displayName || item.name;
+      const description = item.description ? ` - ${item.description}` : "";
+      console.log(
+        `    ${COLORS.muted}\u2022${COLORS.reset} ${item.name} ${COLORS.muted}(${displayName})${description}${COLORS.reset}`
+      );
+    }
+    console.log("");
+  }
+}
+
+// src/cli/commands/diff.ts
+init_constants();
+init_config();
+init_registry();
+function diffCommand() {
+  const command = new Command("diff");
+  command.description("Show differences between local and registry versions").argument("[items...]", "Components or blocks to diff (default: all installed)").option("-c, --cwd <path>", "Working directory", process.cwd()).action(async (items, options) => {
+    await runDiff(items, options);
+  });
+  return command;
+}
+async function runDiff(items, options) {
+  const cwd = options.cwd || process.cwd();
+  const config = await loadConfig(cwd);
+  if (!config) {
+    log.error("No prism.config.json found. Run `prism init` first.");
+    process.exit(1);
+  }
+  console.log("");
+  log.info("Checking for updates...");
+  console.log("");
+  const installedItems = await findInstalledItems(config, items);
+  if (installedItems.length === 0) {
+    log.info("No Prism components or blocks found in your project.");
+    log.muted("Run `prism add <component>` to add components.");
+    return;
+  }
+  const diffs = [];
+  for (const item of installedItems) {
+    const status = await checkItemStatus(item, config);
+    diffs.push({ name: item.name, status });
+  }
+  const upToDate = diffs.filter((d) => d.status === "up-to-date");
+  const outdated = diffs.filter((d) => d.status === "outdated");
+  const modified = diffs.filter((d) => d.status === "modified");
+  const unknown = diffs.filter((d) => d.status === "unknown");
+  if (upToDate.length > 0) {
+    console.log(`${COLORS.success}Up to date (${upToDate.length}):${COLORS.reset}`);
+    for (const item of upToDate) {
+      console.log(`  ${COLORS.muted}\u2713${COLORS.reset} ${item.name}`);
+    }
+    console.log("");
+  }
+  if (modified.length > 0) {
+    console.log(`${COLORS.warning}Modified locally (${modified.length}):${COLORS.reset}`);
+    for (const item of modified) {
+      console.log(`  ${COLORS.warning}~${COLORS.reset} ${item.name}`);
+    }
+    console.log("");
+    log.muted("Modified items have local changes. Use --overwrite with update to replace.");
+  }
+  if (outdated.length > 0) {
+    console.log(`${COLORS.primary}Updates available (${outdated.length}):${COLORS.reset}`);
+    for (const item of outdated) {
+      console.log(`  ${COLORS.primary}\u2191${COLORS.reset} ${item.name}`);
+    }
+    console.log("");
+    log.info("Run `prism update` to update outdated components.");
+  }
+  if (unknown.length > 0) {
+    console.log(`${COLORS.muted}Unknown (${unknown.length}):${COLORS.reset}`);
+    for (const item of unknown) {
+      console.log(`  ${COLORS.muted}?${COLORS.reset} ${item.name}`);
+    }
+    console.log("");
+  }
+  console.log("");
+}
+async function findInstalledItems(config, filterItems) {
+  const items = [];
+  const componentsDir = getComponentPath("", config);
+  if (fs6.existsSync(componentsDir)) {
+    const entries = await fs6.promises.readdir(componentsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const name = entry.name;
+        if (filterItems.length === 0 || filterItems.includes(name)) {
+          items.push({
+            name,
+            type: "component",
+            path: path.join(componentsDir, name)
+          });
+        }
+      }
+    }
+  }
+  const blocksDir = getBlockPath("", config);
+  if (fs6.existsSync(blocksDir)) {
+    const entries = await fs6.promises.readdir(blocksDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const name = entry.name;
+        if (filterItems.length === 0 || filterItems.includes(name) || filterItems.includes(`block:${name}`)) {
+          items.push({
+            name,
+            type: "block",
+            path: path.join(blocksDir, name)
+          });
+        }
+      }
+    }
+  }
+  return items;
+}
+async function checkItemStatus(item, config) {
+  const registry2 = item.type === "block" ? defaultRegistrySchema.blocks : defaultRegistrySchema.components;
+  const definition = registry2[item.name];
+  if (!definition) {
+    return "unknown";
+  }
+  const lockfilePath = path.join(config.rootDir, "prism.lock.json");
+  let installedVersion;
+  if (fs6.existsSync(lockfilePath)) {
+    try {
+      const lockfile = JSON.parse(await fs6.promises.readFile(lockfilePath, "utf-8"));
+      const installed = item.type === "block" ? lockfile.blocks?.[item.name] : lockfile.components?.[item.name];
+      installedVersion = installed?.version;
+    } catch {
+    }
+  }
+  if (installedVersion && installedVersion !== definition.version) {
+    return "outdated";
+  }
+  const hasModifications = await checkForLocalModifications(item, definition);
+  if (hasModifications) {
+    return "modified";
+  }
+  return "up-to-date";
+}
+async function checkForLocalModifications(item, definition, _config) {
+  for (const file of definition.files) {
+    const filePath = path.join(item.path, file.path);
+    if (!fs6.existsSync(filePath)) {
+      return true;
+    }
+  }
+  const localFiles = await fs6.promises.readdir(item.path);
+  const expectedFiles = new Set(definition.files.map((f) => f.path));
+  for (const localFile of localFiles) {
+    if (localFile.startsWith(".") || localFile === "node_modules") {
+      continue;
+    }
+    if (!expectedFiles.has(localFile)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/cli/commands/update.ts
+init_constants();
+init_config();
+init_registry();
+function updateCommand() {
+  const command = new Command("update");
+  command.description("Update installed components and blocks").argument("[items...]", "Components or blocks to update (default: all installed)").option("-y, --yes", "Skip confirmation prompts").option("-o, --overwrite", "Overwrite modified files").option("-a, --all", "Update all installed items").option("-c, --cwd <path>", "Working directory", process.cwd()).action(async (items, options) => {
+    await runUpdate(items, options);
+  });
+  return command;
+}
+async function runUpdate(items, options) {
+  const cwd = options.cwd || process.cwd();
+  const config = await loadConfig(cwd);
+  if (!config) {
+    log.error("No prism.config.json found. Run `prism init` first.");
+    process.exit(1);
+  }
+  console.log("");
+  log.info("Checking for updates...");
+  console.log("");
+  const installedItems = await findInstalledItems2(config, items, options.all);
+  if (installedItems.length === 0) {
+    log.info("No Prism components or blocks found to update.");
+    return;
+  }
+  const toUpdate = [];
+  for (const item of installedItems) {
+    const hasUpdate = await checkForUpdate(item, config);
+    if (hasUpdate) {
+      toUpdate.push(item);
+    }
+  }
+  if (toUpdate.length === 0) {
+    log.success("All items are up to date!");
+    return;
+  }
+  log.info(`Found ${toUpdate.length} item(s) to update:`);
+  for (const item of toUpdate) {
+    console.log(`  \u2022 ${item.name}`);
+  }
+  console.log("");
+  const results = [];
+  for (const item of toUpdate) {
+    try {
+      await updateItem(item, config, options);
+      results.push({ name: item.name, success: true });
+      log.success(`Updated ${item.name}`);
+    } catch (error) {
+      results.push({ name: item.name, success: false, error: error.message });
+      log.error(`Failed to update ${item.name}: ${error.message}`);
+    }
+  }
+  console.log("");
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.filter((r) => !r.success).length;
+  if (successCount > 0) {
+    log.success(`Updated ${successCount} item(s) successfully.`);
+  }
+  if (failCount > 0) {
+    log.error(`Failed to update ${failCount} item(s).`);
+  }
+  console.log("");
+}
+async function findInstalledItems2(config, filterItems, all) {
+  const items = [];
+  const componentsDir = getComponentPath("", config);
+  if (fs6.existsSync(componentsDir)) {
+    const entries = await fs6.promises.readdir(componentsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const name = entry.name;
+        if (all || filterItems.length === 0 || filterItems.includes(name)) {
+          items.push({
+            name,
+            type: "component",
+            path: path.join(componentsDir, name)
+          });
+        }
+      }
+    }
+  }
+  const blocksDir = getBlockPath("", config);
+  if (fs6.existsSync(blocksDir)) {
+    const entries = await fs6.promises.readdir(blocksDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const name = entry.name;
+        if (all || filterItems.length === 0 || filterItems.includes(name) || filterItems.includes(`block:${name}`)) {
+          items.push({
+            name,
+            type: "block",
+            path: path.join(blocksDir, name)
+          });
+        }
+      }
+    }
+  }
+  return items;
+}
+async function checkForUpdate(item, config) {
+  const registry2 = item.type === "block" ? defaultRegistrySchema.blocks : defaultRegistrySchema.components;
+  const definition = registry2[item.name];
+  if (!definition) {
+    return false;
+  }
+  const lockfilePath = path.join(config.rootDir, "prism.lock.json");
+  if (fs6.existsSync(lockfilePath)) {
+    try {
+      const lockfile = JSON.parse(await fs6.promises.readFile(lockfilePath, "utf-8"));
+      const installed = item.type === "block" ? lockfile.blocks?.[item.name] : lockfile.components?.[item.name];
+      if (installed?.version && installed.version !== definition.version) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+async function updateItem(item, config, options) {
+  const registry2 = item.type === "block" ? defaultRegistrySchema.blocks : defaultRegistrySchema.components;
+  const definition = registry2[item.name];
+  if (!definition) {
+    throw new Error("Item not found in registry");
+  }
+  if (!options.overwrite) {
+    const backupDir = path.join(item.path, ".prism-backup");
+    await fs6.promises.mkdir(backupDir, { recursive: true });
+    for (const file of definition.files) {
+      const filePath = path.join(item.path, file.path);
+      if (fs6.existsSync(filePath)) {
+        const backupPath = path.join(backupDir, file.path);
+        await fs6.promises.copyFile(filePath, backupPath);
+      }
+    }
+    log.muted(`  Backed up ${definition.files.length} file(s) to .prism-backup/`);
+  }
+  const { generateFileContent: generateFileContent2 } = await Promise.resolve().then(() => (init_add(), add_exports));
+  for (const file of definition.files) {
+    const filePath = path.join(item.path, file.path);
+    const content = generateFileContent2(
+      item.name,
+      file.path,
+      file.type,
+      definition,
+      item.type === "block"
+    );
+    await fs6.promises.writeFile(filePath, content, "utf-8");
+  }
+  log.muted(`  Updated ${definition.files.length} file(s) in ${path.relative(config.rootDir, item.path)}/`);
+  const lockfilePath = path.join(config.rootDir, "prism.lock.json");
+  let lockfile = {
+    version: "1",
+    components: {},
+    blocks: {}
+  };
+  if (fs6.existsSync(lockfilePath)) {
+    try {
+      lockfile = JSON.parse(await fs6.promises.readFile(lockfilePath, "utf-8"));
+    } catch {
+    }
+  }
+  const entry = {
+    name: item.name,
+    version: definition.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (item.type === "block") {
+    lockfile.blocks[item.name] = entry;
+  } else {
+    lockfile.components[item.name] = entry;
+  }
+  await fs6.promises.writeFile(lockfilePath, JSON.stringify(lockfile, null, 2), "utf-8");
+}
+
+// src/cli/commands/remove.ts
+init_constants();
+init_config();
+function removeCommand() {
+  const command = new Command("remove");
+  command.description("Remove components or blocks from your project").argument("<items...>", "Components or blocks to remove").option("-y, --yes", "Skip confirmation prompts").option("-f, --force", "Force removal even if files have been modified").option("-c, --cwd <path>", "Working directory", process.cwd()).action(async (items, options) => {
+    await runRemove(items, options);
+  });
+  return command;
+}
+async function runRemove(items, options) {
+  const cwd = options.cwd || process.cwd();
+  const config = await loadConfig(cwd);
+  if (!config) {
+    log.error("No prism.config.json found. Run `prism init` first.");
+    process.exit(1);
+  }
+  if (items.length === 0) {
+    log.error("No items specified. Use `prism remove <component>` or `prism remove block:<name>`");
+    process.exit(1);
+  }
+  console.log("");
+  log.info(`Removing ${items.length} item(s)...`);
+  console.log("");
+  const results = [];
+  for (const item of items) {
+    try {
+      const result = await removeItem(item, config, options);
+      results.push(result);
+    } catch (error) {
+      results.push({
+        name: item,
+        success: false,
+        error: error.message
+      });
+    }
+  }
+  console.log("");
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.filter((r) => !r.success).length;
+  if (successCount > 0) {
+    log.success(`Removed ${successCount} item(s) successfully.`);
+  }
+  if (failCount > 0) {
+    log.error(`Failed to remove ${failCount} item(s):`);
+    for (const result of results.filter((r) => !r.success)) {
+      log.muted(`  - ${result.name}: ${result.error}`);
+    }
+    process.exit(1);
+  }
+}
+async function removeItem(item, config, options) {
+  const isBlock = item.startsWith("block:");
+  const name = isBlock ? item.replace("block:", "") : item;
+  const itemPath = isBlock ? getBlockPath(name, config) : getComponentPath(name, config);
+  if (!fs6.existsSync(itemPath)) {
+    return {
+      name: item,
+      success: false,
+      error: `Not installed at ${path.relative(config.rootDir, itemPath)}`
+    };
+  }
+  try {
+    await fs6.promises.rm(itemPath, { recursive: true, force: true });
+    log.success(`Removed ${name} from ${path.relative(config.rootDir, itemPath)}/`);
+    await updateLockfile2(config.rootDir, name, isBlock);
+    return { name: item, success: true };
+  } catch (error) {
+    return {
+      name: item,
+      success: false,
+      error: `Failed to remove: ${error.message}`
+    };
+  }
+}
+async function updateLockfile2(rootDir, name, isBlock) {
+  const lockfilePath = path.join(rootDir, "prism.lock.json");
+  if (!fs6.existsSync(lockfilePath)) {
+    return;
+  }
+  try {
+    const lockfile = JSON.parse(await fs6.promises.readFile(lockfilePath, "utf-8"));
+    if (isBlock) {
+      delete lockfile.blocks[name];
+    } else {
+      delete lockfile.components[name];
+    }
+    await fs6.promises.writeFile(lockfilePath, JSON.stringify(lockfile, null, 2) + "\n", "utf-8");
+    log.muted(`  Updated prism.lock.json`);
+  } catch {
+    log.warning("  Could not update lockfile");
+  }
+}
+
+// src/cli/commands/doctor.ts
+init_constants();
+init_config();
+function doctorCommand() {
+  const command = new Command("doctor");
+  command.description("Diagnose project configuration and environment").option("-c, --cwd <path>", "Working directory", process.cwd()).action(async (options) => {
+    await runDoctor(options);
+  });
+  return command;
+}
+async function runDoctor(options) {
+  const cwd = options.cwd || process.cwd();
+  console.log("");
+  log.info("Prism Doctor - Checking project health...");
+  console.log("");
+  const checks = [];
+  checks.push(await checkConfigFile(cwd));
+  checks.push(...await checkPackageJson(cwd));
+  const config = await loadConfig(cwd);
+  if (config) {
+    checks.push(...checkDirectories(config));
+  }
+  checks.push(await checkTsConfig(cwd));
+  checks.push(await checkLockfile(cwd));
+  console.log("");
+  const passCount = checks.filter((c) => c.status === "pass").length;
+  const warnCount = checks.filter((c) => c.status === "warn").length;
+  const failCount = checks.filter((c) => c.status === "fail").length;
+  for (const check of checks) {
+    const icon = check.status === "pass" ? `${COLORS.success}\u2713${COLORS.reset}` : check.status === "warn" ? `${COLORS.warning}\u26A0${COLORS.reset}` : `${COLORS.error}\u2716${COLORS.reset}`;
+    console.log(`  ${icon} ${check.name}: ${check.message}`);
+  }
+  console.log("");
+  console.log(
+    `  ${COLORS.success}${passCount} passed${COLORS.reset}` + (warnCount > 0 ? `, ${COLORS.warning}${warnCount} warnings${COLORS.reset}` : "") + (failCount > 0 ? `, ${COLORS.error}${failCount} failed${COLORS.reset}` : "")
+  );
+  console.log("");
+  if (failCount > 0) {
+    process.exit(1);
+  }
+}
+async function checkConfigFile(cwd) {
+  const configPath = findConfigFile(cwd);
+  if (!configPath) {
+    return {
+      name: "Config file",
+      status: "fail",
+      message: "prism.config.json not found. Run `prism init` to create one."
+    };
+  }
+  return {
+    name: "Config file",
+    status: "pass",
+    message: `Found at ${path.relative(cwd, configPath)}`
+  };
+}
+async function checkPackageJson(cwd) {
+  const results = [];
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs6.existsSync(pkgPath)) {
+    results.push({
+      name: "package.json",
+      status: "fail",
+      message: "Not found in project root."
+    });
+    return results;
+  }
+  try {
+    const pkg2 = JSON.parse(await fs6.promises.readFile(pkgPath, "utf-8"));
+    const allDeps = { ...pkg2.dependencies, ...pkg2.devDependencies, ...pkg2.peerDependencies };
+    const requiredPeers = ["react", "react-dom", "@mui/material"];
+    for (const dep of requiredPeers) {
+      if (allDeps[dep]) {
+        results.push({
+          name: dep,
+          status: "pass",
+          message: `${allDeps[dep]}`
+        });
+      } else {
+        results.push({
+          name: dep,
+          status: "fail",
+          message: "Not installed. Required peer dependency."
+        });
+      }
+    }
+    const optionalDeps = ["@emotion/react", "@emotion/styled", "zustand"];
+    for (const dep of optionalDeps) {
+      if (allDeps[dep]) {
+        results.push({
+          name: dep,
+          status: "pass",
+          message: `${allDeps[dep]}`
+        });
+      } else {
+        results.push({
+          name: dep,
+          status: "warn",
+          message: "Not installed. Recommended dependency."
+        });
+      }
+    }
+  } catch {
+    results.push({
+      name: "package.json",
+      status: "fail",
+      message: "Failed to parse."
+    });
+  }
+  return results;
+}
+function checkDirectories(config) {
+  const results = [];
+  const dirs = {
+    components: config.aliases.components,
+    blocks: config.aliases.blocks,
+    hooks: config.aliases.hooks,
+    utils: config.aliases.utils
+  };
+  for (const [name, alias] of Object.entries(dirs)) {
+    const resolved = resolveAlias(alias, config);
+    if (fs6.existsSync(resolved)) {
+      results.push({
+        name: `${name} directory`,
+        status: "pass",
+        message: `Exists at ${path.relative(config.rootDir, resolved)}`
+      });
+    } else {
+      results.push({
+        name: `${name} directory`,
+        status: "warn",
+        message: `Not found at ${path.relative(config.rootDir, resolved)}. Will be created on first add.`
+      });
+    }
+  }
+  return results;
+}
+async function checkTsConfig(cwd) {
+  const tsConfigPath = path.join(cwd, "tsconfig.json");
+  if (!fs6.existsSync(tsConfigPath)) {
+    return {
+      name: "TypeScript",
+      status: "warn",
+      message: "tsconfig.json not found. Path aliases may not work."
+    };
+  }
+  try {
+    const content = await fs6.promises.readFile(tsConfigPath, "utf-8");
+    const stripped = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    const tsConfig = JSON.parse(stripped);
+    const paths = tsConfig.compilerOptions?.paths || tsConfig.compilerOptions?.baseUrl;
+    if (paths) {
+      return {
+        name: "TypeScript",
+        status: "pass",
+        message: "Path aliases configured."
+      };
+    }
+    return {
+      name: "TypeScript",
+      status: "warn",
+      message: "No path aliases found. Ensure @ alias is configured for Prism imports."
+    };
+  } catch {
+    return {
+      name: "TypeScript",
+      status: "warn",
+      message: "Could not parse tsconfig.json."
+    };
+  }
+}
+async function checkLockfile(cwd) {
+  const lockfilePath = path.join(cwd, "prism.lock.json");
+  if (!fs6.existsSync(lockfilePath)) {
+    return {
+      name: "Lockfile",
+      status: "pass",
+      message: "No lockfile yet (no components installed)."
+    };
+  }
+  try {
+    const lockfile = JSON.parse(await fs6.promises.readFile(lockfilePath, "utf-8"));
+    const componentCount = Object.keys(lockfile.components || {}).length;
+    const blockCount = Object.keys(lockfile.blocks || {}).length;
+    return {
+      name: "Lockfile",
+      status: "pass",
+      message: `${componentCount} component(s), ${blockCount} block(s) installed.`
+    };
+  } catch {
+    return {
+      name: "Lockfile",
+      status: "warn",
+      message: "Lockfile exists but could not be parsed."
+    };
+  }
+}
+
+// src/cli/index.ts
+init_constants();
+init_add();
+init_constants();
+function createCli() {
+  const program = new Command();
+  program.name("prism").description("Prism Design System CLI - Component installation and management").version(PRISM_VERSION, "-v, --version", "Display the current version");
+  program.addCommand(initCommand());
+  program.addCommand(addCommand());
+  program.addCommand(removeCommand());
+  program.addCommand(listCommand());
+  program.addCommand(diffCommand());
+  program.addCommand(updateCommand());
+  program.addCommand(doctorCommand());
+  return program;
+}
+async function cli() {
+  const program = createCli();
+  await program.parseAsync(process.argv);
+}
+
+export { DEFAULT_CONFIG, PRISM_VERSION, addCommand, cli, createCli, diffCommand, doctorCommand, initCommand, listCommand, removeCommand, updateCommand };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map