@omnitron-dev/prism 0.3.0 → 0.3.2

package/dist/cli/index.js

@@ -1,13 +1,18 @@
 import { createRequire } from 'module';
-import * as fs6 from 'fs';
+import * as fs5 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 __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -84,7 +89,7 @@ function findConfigFile(startDir = process.cwd()) {
   const root = path.parse(currentDir).root;
   while (currentDir !== root) {
     const configPath = path.join(currentDir, CONFIG_FILE_NAME);
-    if (fs6.existsSync(configPath)) {
+    if (fs5.existsSync(configPath)) {
       return configPath;
     }
     currentDir = path.dirname(currentDir);
@@ -97,7 +102,7 @@ async function loadConfig(cwd = process.cwd()) {
     return null;
   }
   try {
-    const content = await fs6.promises.readFile(configPath, "utf-8");
+    const content = await fs5.promises.readFile(configPath, "utf-8");
     const config = JSON.parse(content);
     return {
       ...DEFAULT_CONFIG,
@@ -112,7 +117,7 @@ async function loadConfig(cwd = process.cwd()) {
 }
 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");
+  await fs5.promises.writeFile(outputPath, content, "utf-8");
 }
 function resolveAlias(alias, config) {
   if (alias.startsWith("@/")) {
@@ -140,372 +145,10 @@ var init_config = __esm({
   }
 });
 
-// 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",
@@ -1200,15 +843,15 @@ async function runAdd(items, options) {
   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";
+  if (fs5.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs5.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];
+  const registry = isBlock ? defaultRegistrySchema.blocks : defaultRegistrySchema.components;
+  const definition = registry[itemName];
   if (!definition) {
     return {
       name: item,
@@ -1217,18 +860,18 @@ async function addItem(item, config, options) {
     };
   }
   const outputPath = options.path ? path.join(config.rootDir, options.path, itemName) : isBlock ? getBlockPath(itemName, config) : getComponentPath(itemName, config);
-  if (fs6.existsSync(outputPath) && !options.overwrite) {
+  if (fs5.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 });
+  await fs5.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");
+    await fs5.promises.writeFile(filePath, content, "utf-8");
   }
   log.success(`Added ${itemName} \u2192 ${path.relative(config.rootDir, outputPath)}/`);
   await updateLockfile(config.rootDir, itemName, definition.version, isBlock);
@@ -1245,9 +888,9 @@ async function updateLockfile(rootDir, name, version, isBlock) {
     components: {},
     blocks: {}
   };
-  if (fs6.existsSync(lockfilePath)) {
+  if (fs5.existsSync(lockfilePath)) {
     try {
-      lockfile = JSON.parse(await fs6.promises.readFile(lockfilePath, "utf-8"));
+      lockfile = JSON.parse(await fs5.promises.readFile(lockfilePath, "utf-8"));
     } catch {
     }
   }
@@ -1261,7 +904,7 @@ async function updateLockfile(rootDir, name, version, isBlock) {
   } else {
     lockfile.components[name] = entry;
   }
-  await fs6.promises.writeFile(lockfilePath, JSON.stringify(lockfile, null, 2) + "\n", "utf-8");
+  await fs5.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("");
@@ -1869,11 +1512,11 @@ async function prompt(question, defaultValue) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve3) => {
+  return new Promise((resolve2) => {
     const displayQuestion = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
     rl.question(displayQuestion, (answer) => {
       rl.close();
-      resolve3(answer.trim() || defaultValue || "");
+      resolve2(answer.trim() || defaultValue || "");
     });
   });
 }
@@ -1919,8 +1562,8 @@ async function runInit(options) {
     path.join(cwd, DEFAULT_UTILS_DIR)
   ];
   for (const dir of dirs) {
-    if (!fs6.existsSync(dir)) {
-      await fs6.promises.mkdir(dir, { recursive: true });
+    if (!fs5.existsSync(dir)) {
+      await fs5.promises.mkdir(dir, { recursive: true });
       log.success(`Created ${path.relative(cwd, dir)}/`);
     }
   }
@@ -1946,7 +1589,7 @@ async function interactiveInit(cwd) {
   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);
+  const hasTailwind = fs5.existsSync(tailwindConfigPath) || fs5.existsSync(tailwindTsConfigPath);
   let tailwindConfig;
   if (hasTailwind) {
     const useTailwind = await confirm("Tailwind CSS detected. Configure CSS variables?", true);
@@ -1954,7 +1597,7 @@ async function interactiveInit(cwd) {
       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",
+        config: fs5.existsSync(tailwindTsConfigPath) ? "tailwind.config.ts" : "tailwind.config.js",
         css: cssFile,
         baseColor,
         cssVariables: true
@@ -2118,8 +1761,8 @@ async function runDiff(items, options) {
 async function findInstalledItems(config, filterItems) {
   const items = [];
   const componentsDir = getComponentPath("", config);
-  if (fs6.existsSync(componentsDir)) {
-    const entries = await fs6.promises.readdir(componentsDir, { withFileTypes: true });
+  if (fs5.existsSync(componentsDir)) {
+    const entries = await fs5.promises.readdir(componentsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         const name = entry.name;
@@ -2134,8 +1777,8 @@ async function findInstalledItems(config, filterItems) {
     }
   }
   const blocksDir = getBlockPath("", config);
-  if (fs6.existsSync(blocksDir)) {
-    const entries = await fs6.promises.readdir(blocksDir, { withFileTypes: true });
+  if (fs5.existsSync(blocksDir)) {
+    const entries = await fs5.promises.readdir(blocksDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         const name = entry.name;
@@ -2152,16 +1795,16 @@ async function findInstalledItems(config, filterItems) {
   return items;
 }
 async function checkItemStatus(item, config) {
-  const registry2 = item.type === "block" ? defaultRegistrySchema.blocks : defaultRegistrySchema.components;
-  const definition = registry2[item.name];
+  const registry = item.type === "block" ? defaultRegistrySchema.blocks : defaultRegistrySchema.components;
+  const definition = registry[item.name];
   if (!definition) {
     return "unknown";
   }
   const lockfilePath = path.join(config.rootDir, "prism.lock.json");
   let installedVersion;
-  if (fs6.existsSync(lockfilePath)) {
+  if (fs5.existsSync(lockfilePath)) {
     try {
-      const lockfile = JSON.parse(await fs6.promises.readFile(lockfilePath, "utf-8"));
+      const lockfile = JSON.parse(await fs5.promises.readFile(lockfilePath, "utf-8"));
       const installed = item.type === "block" ? lockfile.blocks?.[item.name] : lockfile.components?.[item.name];
       installedVersion = installed?.version;
     } catch {
@@ -2179,11 +1822,11 @@ async function checkItemStatus(item, config) {
 async function checkForLocalModifications(item, definition, _config) {
   for (const file of definition.files) {
     const filePath = path.join(item.path, file.path);
-    if (!fs6.existsSync(filePath)) {
+    if (!fs5.existsSync(filePath)) {
       return true;
     }
   }
-  const localFiles = await fs6.promises.readdir(item.path);
+  const localFiles = await fs5.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") {
@@ -2263,8 +1906,8 @@ async function runUpdate(items, options) {
 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 });
+  if (fs5.existsSync(componentsDir)) {
+    const entries = await fs5.promises.readdir(componentsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         const name = entry.name;
@@ -2279,8 +1922,8 @@ async function findInstalledItems2(config, filterItems, all) {
     }
   }
   const blocksDir = getBlockPath("", config);
-  if (fs6.existsSync(blocksDir)) {
-    const entries = await fs6.promises.readdir(blocksDir, { withFileTypes: true });
+  if (fs5.existsSync(blocksDir)) {
+    const entries = await fs5.promises.readdir(blocksDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         const name = entry.name;
@@ -2297,15 +1940,15 @@ async function findInstalledItems2(config, filterItems, all) {
   return items;
 }
 async function checkForUpdate(item, config) {
-  const registry2 = item.type === "block" ? defaultRegistrySchema.blocks : defaultRegistrySchema.components;
-  const definition = registry2[item.name];
+  const registry = item.type === "block" ? defaultRegistrySchema.blocks : defaultRegistrySchema.components;
+  const definition = registry[item.name];
   if (!definition) {
     return false;
   }
   const lockfilePath = path.join(config.rootDir, "prism.lock.json");
-  if (fs6.existsSync(lockfilePath)) {
+  if (fs5.existsSync(lockfilePath)) {
     try {
-      const lockfile = JSON.parse(await fs6.promises.readFile(lockfilePath, "utf-8"));
+      const lockfile = JSON.parse(await fs5.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;
@@ -2316,19 +1959,19 @@ async function checkForUpdate(item, config) {
   return false;
 }
 async function updateItem(item, config, options) {
-  const registry2 = item.type === "block" ? defaultRegistrySchema.blocks : defaultRegistrySchema.components;
-  const definition = registry2[item.name];
+  const registry = item.type === "block" ? defaultRegistrySchema.blocks : defaultRegistrySchema.components;
+  const definition = registry[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 });
+    await fs5.promises.mkdir(backupDir, { recursive: true });
     for (const file of definition.files) {
       const filePath = path.join(item.path, file.path);
-      if (fs6.existsSync(filePath)) {
+      if (fs5.existsSync(filePath)) {
         const backupPath = path.join(backupDir, file.path);
-        await fs6.promises.copyFile(filePath, backupPath);
+        await fs5.promises.copyFile(filePath, backupPath);
       }
     }
     log.muted(`  Backed up ${definition.files.length} file(s) to .prism-backup/`);
@@ -2343,7 +1986,7 @@ async function updateItem(item, config, options) {
       definition,
       item.type === "block"
     );
-    await fs6.promises.writeFile(filePath, content, "utf-8");
+    await fs5.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");
@@ -2352,9 +1995,9 @@ async function updateItem(item, config, options) {
     components: {},
     blocks: {}
   };
-  if (fs6.existsSync(lockfilePath)) {
+  if (fs5.existsSync(lockfilePath)) {
     try {
-      lockfile = JSON.parse(await fs6.promises.readFile(lockfilePath, "utf-8"));
+      lockfile = JSON.parse(await fs5.promises.readFile(lockfilePath, "utf-8"));
     } catch {
     }
   }
@@ -2368,7 +2011,7 @@ async function updateItem(item, config, options) {
   } else {
     lockfile.components[item.name] = entry;
   }
-  await fs6.promises.writeFile(lockfilePath, JSON.stringify(lockfile, null, 2), "utf-8");
+  await fs5.promises.writeFile(lockfilePath, JSON.stringify(lockfile, null, 2), "utf-8");
 }
 
 // src/cli/commands/remove.ts
@@ -2426,7 +2069,7 @@ 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)) {
+  if (!fs5.existsSync(itemPath)) {
     return {
       name: item,
       success: false,
@@ -2434,7 +2077,7 @@ async function removeItem(item, config, options) {
     };
   }
   try {
-    await fs6.promises.rm(itemPath, { recursive: true, force: true });
+    await fs5.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 };
@@ -2448,17 +2091,17 @@ async function removeItem(item, config, options) {
 }
 async function updateLockfile2(rootDir, name, isBlock) {
   const lockfilePath = path.join(rootDir, "prism.lock.json");
-  if (!fs6.existsSync(lockfilePath)) {
+  if (!fs5.existsSync(lockfilePath)) {
     return;
   }
   try {
-    const lockfile = JSON.parse(await fs6.promises.readFile(lockfilePath, "utf-8"));
+    const lockfile = JSON.parse(await fs5.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");
+    await fs5.promises.writeFile(lockfilePath, JSON.stringify(lockfile, null, 2) + "\n", "utf-8");
     log.muted(`  Updated prism.lock.json`);
   } catch {
     log.warning("  Could not update lockfile");
@@ -2524,7 +2167,7 @@ async function checkConfigFile(cwd) {
 async function checkPackageJson(cwd) {
   const results = [];
   const pkgPath = path.join(cwd, "package.json");
-  if (!fs6.existsSync(pkgPath)) {
+  if (!fs5.existsSync(pkgPath)) {
     results.push({
       name: "package.json",
       status: "fail",
@@ -2533,7 +2176,7 @@ async function checkPackageJson(cwd) {
     return results;
   }
   try {
-    const pkg2 = JSON.parse(await fs6.promises.readFile(pkgPath, "utf-8"));
+    const pkg2 = JSON.parse(await fs5.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) {
@@ -2586,7 +2229,7 @@ function checkDirectories(config) {
   };
   for (const [name, alias] of Object.entries(dirs)) {
     const resolved = resolveAlias(alias, config);
-    if (fs6.existsSync(resolved)) {
+    if (fs5.existsSync(resolved)) {
       results.push({
         name: `${name} directory`,
         status: "pass",
@@ -2604,7 +2247,7 @@ function checkDirectories(config) {
 }
 async function checkTsConfig(cwd) {
   const tsConfigPath = path.join(cwd, "tsconfig.json");
-  if (!fs6.existsSync(tsConfigPath)) {
+  if (!fs5.existsSync(tsConfigPath)) {
     return {
       name: "TypeScript",
       status: "warn",
@@ -2612,7 +2255,7 @@ async function checkTsConfig(cwd) {
     };
   }
   try {
-    const content = await fs6.promises.readFile(tsConfigPath, "utf-8");
+    const content = await fs5.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;
@@ -2638,7 +2281,7 @@ async function checkTsConfig(cwd) {
 }
 async function checkLockfile(cwd) {
   const lockfilePath = path.join(cwd, "prism.lock.json");
-  if (!fs6.existsSync(lockfilePath)) {
+  if (!fs5.existsSync(lockfilePath)) {
     return {
       name: "Lockfile",
       status: "pass",
@@ -2646,7 +2289,7 @@ async function checkLockfile(cwd) {
     };
   }
   try {
-    const lockfile = JSON.parse(await fs6.promises.readFile(lockfilePath, "utf-8"));
+    const lockfile = JSON.parse(await fs5.promises.readFile(lockfilePath, "utf-8"));
     const componentCount = Object.keys(lockfile.components || {}).length;
     const blockCount = Object.keys(lockfile.blocks || {}).length;
     return {