sigma-ui 1.1.1 → 1.2.0

package/dist/index.js

@@ -8,22 +8,80 @@ import process6 from "node:process";
 import { Command as Command4 } from "commander";
 
 // src/commands/add.ts
-import { execSync } from "node:child_process";
-import { existsSync as existsSync2, promises as fs3 } from "node:fs";
+import { existsSync as existsSync3, promises as fs3 } from "node:fs";
 import process3 from "node:process";
-import path4 from "pathe";
+import path5 from "pathe";
 import { consola as consola3 } from "consola";
 import { colors as colors2 } from "consola/utils";
 import { Command } from "commander";
 import ora from "ora";
 import prompts from "prompts";
 import { z as z2 } from "zod";
-import { addDependency, addDevDependency, detectPackageManager } from "nypm";
+
+// src/utils/package-manager.ts
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import path from "pathe";
+async function detectPackageManager(cwd) {
+  const lockFiles = [
+    { name: "pnpm", files: ["pnpm-lock.yaml", "pnpm-workspace.yaml"] },
+    { name: "yarn", files: ["yarn.lock"] },
+    { name: "bun", files: ["bun.lockb"] },
+    { name: "npm", files: ["package-lock.json"] }
+  ];
+  for (const pm of lockFiles) {
+    for (const file of pm.files) {
+      if (existsSync(path.join(cwd, file))) {
+        return { name: pm.name };
+      }
+    }
+  }
+  try {
+    const packageJsonPath = path.join(cwd, "package.json");
+    if (existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      if (packageJson.packageManager) {
+        const [name, version] = packageJson.packageManager.split("@");
+        return { name, version };
+      }
+    }
+  } catch {
+  }
+  return { name: "pnpm" };
+}
+async function addDependency(dependencies, options8 = { cwd: process.cwd() }) {
+  await installPackages(dependencies, "dependencies", options8);
+}
+async function addDevDependency(dependencies, options8 = { cwd: process.cwd() }) {
+  await installPackages(dependencies, "devDependencies", options8);
+}
+async function installPackages(dependencies, type2, options8 = { cwd: process.cwd() }) {
+  const pm = await detectPackageManager(options8.cwd);
+  const devFlag = type2 === "devDependencies" ? "-D " : "";
+  let command = "";
+  switch (pm?.name) {
+    case "npm":
+      command = `npm install ${devFlag}${dependencies.join(" ")}`;
+      break;
+    case "yarn":
+      command = `yarn add ${devFlag}${dependencies.join(" ")}`;
+      break;
+    case "bun":
+      command = `bun add ${devFlag}${dependencies.join(" ")}`;
+      break;
+    case "pnpm":
+    default:
+      command = `pnpm add ${devFlag}${dependencies.join(" ")}`;
+      break;
+  }
+  const stdio = options8.silent ? "pipe" : "inherit";
+  execSync(command, { cwd: options8.cwd, stdio });
+}
 
 // src/utils/transformers/index.ts
 import { promises as fs } from "node:fs";
 import { tmpdir } from "node:os";
-import path from "pathe";
+import path2 from "pathe";
 import { Project, ScriptKind } from "ts-morph";
 
 // src/utils/transformers/transform-import.ts
@@ -67,8 +125,8 @@ var project = new Project({
   compilerOptions: {}
 });
 async function createTempSourceFile(filename) {
-  const dir = await fs.mkdtemp(path.join(tmpdir(), "sigma-ui-"));
-  return path.join(dir, filename);
+  const dir = await fs.mkdtemp(path2.join(tmpdir(), "sigma-ui-"));
+  return path2.join(dir, filename);
 }
 async function transform(opts) {
   const tempFile = await createTempSourceFile(opts.filename);
@@ -81,10 +139,47 @@ async function transform(opts) {
   return sourceFile?.getFullText();
 }
 
+// src/utils/transformers/transform-component-naming.ts
+function pascalToKebab(pascalCase) {
+  return pascalCase.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+function kebabToPascal(kebabCase) {
+  return kebabCase.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function transformDirectoryName(dirName, naming) {
+  if (naming === "kebab-case") {
+    return dirName;
+  }
+  return kebabToPascal(dirName);
+}
+function transformFileName(fileName, naming) {
+  if (naming === "pascal-case") {
+    return fileName;
+  }
+  if (fileName === "index.ts") {
+    return fileName;
+  }
+  const extension = fileName.includes(".") ? fileName.slice(fileName.lastIndexOf(".")) : "";
+  const baseName = fileName.includes(".") ? fileName.slice(0, fileName.lastIndexOf(".")) : fileName;
+  return pascalToKebab(baseName) + extension;
+}
+function transformLocalVueImports(content, naming) {
+  if (naming === "pascal-case") {
+    return content;
+  }
+  return content.replace(
+    /from\s+['"]\.\/([\w-]+)\.vue['"]/g,
+    (match, componentName) => {
+      const kebabName = pascalToKebab(componentName);
+      return `from './${kebabName}.vue'`;
+    }
+  );
+}
+
 // src/utils/get-config.ts
-import { existsSync } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import process2 from "node:process";
-import path2 from "pathe";
+import path3 from "pathe";
 import { loadConfig as c12LoadConfig } from "c12";
 import { loadConfig } from "tsconfig-paths";
 import consola from "consola";
@@ -159,6 +254,7 @@ var registryBaseColorSchema = z.object({
     })
   })
 });
+var componentNamingSchema = z.enum(["pascal-case", "kebab-case"]).default("pascal-case");
 var rawConfigSchema = z.object({
   $schema: z.string().optional(),
   styleSystem: commonFields.styleSystem,
@@ -175,7 +271,8 @@ var rawConfigSchema = z.object({
     utils: z.string().default(""),
     components: z.string()
   }),
-  generatePreflight: z.boolean().optional().default(true)
+  generatePreflight: z.boolean().optional().default(true),
+  componentNaming: componentNamingSchema
 });
 var configSchema = rawConfigSchema.extend({
   resolvedPaths: z.object({
@@ -187,7 +284,8 @@ var configSchema = rawConfigSchema.extend({
 });
 var initOptionsSchema = z.object({
   cwd: commonFields.cwd,
-  yes: commonFields.yes
+  yes: commonFields.yes,
+  defaults: z.boolean().default(false)
 });
 var addOptionsSchema = z.object({
   components: commonFields.components,
@@ -238,14 +336,14 @@ async function handleConfigIsMissing() {
 }
 async function resolveConfigPaths(cwd, config) {
   let tsConfig;
-  let tsConfigPath = path2.resolve(
+  let tsConfigPath = path3.resolve(
     cwd,
     config.tsConfigPath
   );
   tsConfig = loadConfig(tsConfigPath);
   if ("paths" in tsConfig && Object.keys(tsConfig.paths).length === 0) {
-    tsConfigPath = path2.resolve(cwd, "./tsconfig.app.json");
-    if (existsSync(tsConfigPath)) {
+    tsConfigPath = path3.resolve(cwd, "./tsconfig.app.json");
+    if (existsSync2(tsConfigPath)) {
       tsConfig = loadConfig(tsConfigPath);
     }
   }
@@ -257,8 +355,8 @@ async function resolveConfigPaths(cwd, config) {
   return configSchema.parse({
     ...config,
     resolvedPaths: {
-      tailwindConfig: path2.resolve(cwd, config.tailwind.config),
-      tailwindCss: path2.resolve(cwd, config.cssPath),
+      tailwindConfig: path3.resolve(cwd, config.tailwind.config),
+      tailwindCss: path3.resolve(cwd, config.cssPath),
       utils: resolveImport(config.aliases.utils, tsConfig),
       components: resolveImport(config.aliases.components, tsConfig)
     }
@@ -297,7 +395,7 @@ function handleError(error) {
 
 // src/utils/registry/index.ts
 import fs2 from "node:fs";
-import path3 from "pathe";
+import path4 from "pathe";
 
 // ../../apps/docs/src/lib/registry/themes.ts
 var themes = [
@@ -756,7 +854,7 @@ function getItemTargetPath(config, item, override) {
   if (!(parent in config.resolvedPaths)) {
     return null;
   }
-  return path3.join(
+  return path4.join(
     config.resolvedPaths[parent] ?? "",
     type2
   );
@@ -818,8 +916,8 @@ function parseOptions(components, opts) {
   });
 }
 function validateAndResolveCwd(cwd) {
-  const resolvedCwd = path4.resolve(cwd);
-  if (!existsSync2(resolvedCwd)) {
+  const resolvedCwd = path5.resolve(cwd);
+  if (!existsSync3(resolvedCwd)) {
     consola3.error(`The path ${resolvedCwd} does not exist. Try again.`);
     process3.exit(1);
   }
@@ -880,7 +978,7 @@ async function processPayload(payload, options8, config, baseColor, cwd, selecte
     const targetDir = getItemTargetPath(
       config,
       item,
-      options8.path ? path4.resolve(cwd, options8.path) : void 0
+      options8.path ? path5.resolve(cwd, options8.path) : void 0
     );
     if (!targetDir) {
       continue;
@@ -891,12 +989,14 @@ async function processPayload(payload, options8, config, baseColor, cwd, selecte
 }
 async function processItem(item, targetDir, options8, config, baseColor, cwd, selectedComponents, spinner) {
   try {
-    if (!existsSync2(targetDir)) {
+    if (!existsSync3(targetDir)) {
       await fs3.mkdir(targetDir, { recursive: true });
     }
-    const componentPath = path4.resolve(targetDir, item.name);
+    const componentNaming = config.componentNaming ?? "pascal-case";
+    const transformedDirName = transformDirectoryName(item.name, componentNaming);
+    const componentPath = path5.resolve(targetDir, transformedDirName);
     const existingComponent = item.files.filter(
-      (file) => existsSync2(path4.resolve(componentPath, file.name))
+      (file) => existsSync3(path5.resolve(componentPath, file.name))
     );
     if (existingComponent.length && !options8.overwrite) {
       if (selectedComponents.includes(item.name)) {
@@ -936,79 +1036,45 @@ async function installDependencies(item, cwd) {
   ].filter(Boolean);
   for (const task of installTasks) {
     try {
-      consola3.info(`Attempting to install ${task.type} using nypm: ${task.deps.join(", ")}`);
+      consola3.info(`Installing ${task.type}: ${task.deps.join(", ")}`);
       await task.installer(task.deps, { cwd });
-      consola3.success(`Successfully installed ${task.type} using nypm.`);
+      consola3.success(`Successfully installed ${task.type}.`);
     } catch (error) {
-      consola3.warn(`nypm failed to install ${task.type}:`, error);
-      const isCorepackError = error instanceof Error && error.message?.includes("corepack");
-      if (isCorepackError) {
-        consola3.info(`Falling back to direct pnpm execution for ${task.type}...`);
-        const pm = await detectPackageManager(cwd);
-        let command = "";
-        const depsString = task.deps.join(" ");
-        const devFlag = task.type === "devDependencies" ? "-D " : "";
-        switch (pm?.name) {
-          case "npm":
-            command = `npm install ${devFlag}${depsString}`;
-            break;
-          case "yarn":
-            command = `yarn add ${devFlag}${depsString}`;
-            break;
-          case "bun":
-            command = `bun add ${devFlag}${depsString}`;
-            break;
-          case "pnpm":
-          default:
-            command = `pnpm add ${devFlag}${depsString}`;
-            break;
-        }
-        try {
-          consola3.info(`Running: ${command}`);
-          execSync(command, { cwd, stdio: "inherit" });
-          consola3.success(`Successfully installed ${task.type} using direct pnpm execution.`);
-        } catch (fallbackError) {
-          const errorMessage = fallbackError instanceof Error ? fallbackError.message : "Unknown error";
-          consola3.error(`Fallback pnpm execution failed for ${task.type}:`, errorMessage);
-          throw new ComponentInstallError(
-            `Failed to install ${task.type} (nypm and fallback failed): ${errorMessage}`,
-            item.name
-          );
-        }
-      } else {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        throw new ComponentInstallError(
-          `Failed to install ${task.type} using nypm: ${errorMessage}`,
-          item.name
-        );
-      }
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      throw new ComponentInstallError(
+        `Failed to install ${task.type}: ${errorMessage}`,
+        item.name
+      );
     }
   }
 }
 async function writeComponentFiles(item, componentDir, config, baseColor) {
-  if (!existsSync2(componentDir)) {
+  if (!existsSync3(componentDir)) {
     await fs3.mkdir(componentDir, { recursive: true });
   }
+  const componentNaming = config.componentNaming ?? "pascal-case";
   const files = item.files.map((file) => ({
     ...file,
-    path: path4.resolve(componentDir, file.name)
+    originalName: file.name,
+    name: transformFileName(file.name, componentNaming),
+    path: path5.resolve(componentDir, transformFileName(file.name, componentNaming))
   }));
   for (const file of files) {
+    const fileContent = transformLocalVueImports(file.content, componentNaming);
     const content = await transform({
       filename: file.path,
-      raw: file.content,
+      raw: fileContent,
       config,
       baseColor
     });
-    const filePath = file.path;
-    await fs3.writeFile(filePath, content);
+    await fs3.writeFile(file.path, content);
   }
 }
 
 // src/commands/diff.ts
-import { existsSync as existsSync3, promises as fs4 } from "node:fs";
+import { existsSync as existsSync4, promises as fs4 } from "node:fs";
 import process4 from "node:process";
-import path5 from "pathe";
+import path6 from "pathe";
 import { consola as consola4 } from "consola";
 import { colors as colors3 } from "consola/utils";
 import { Command as Command2 } from "commander";
@@ -1039,8 +1105,8 @@ function parseOptions2(name, opts) {
   });
 }
 function validateAndResolveCwd2(cwd) {
-  const resolvedCwd = path5.resolve(cwd);
-  if (!existsSync3(resolvedCwd)) {
+  const resolvedCwd = path6.resolve(cwd);
+  if (!existsSync4(resolvedCwd)) {
     consola4.error(`The path ${resolvedCwd} does not exist. Try again.`);
     process4.exit(1);
   }
@@ -1068,8 +1134,8 @@ async function handleAllComponentsDiff(config, registryIndex) {
 function findProjectComponents(registryIndex, targetDir) {
   return registryIndex.filter((item) => {
     return item.files.some((file) => {
-      const fullPath = path5.resolve(targetDir, item.name, file);
-      return existsSync3(fullPath);
+      const fullPath = path6.resolve(targetDir, item.name, file);
+      return existsSync4(fullPath);
     });
   });
 }
@@ -1132,8 +1198,8 @@ async function diffComponent(component, config) {
 }
 async function processItemFiles(item, targetDir, config, baseColor, changes) {
   for (const file of item.files) {
-    const filePath = path5.resolve(targetDir, item.name, file.name);
-    if (!existsSync3(filePath)) {
+    const filePath = path6.resolve(targetDir, item.name, file.name);
+    if (!existsSync4(filePath)) {
       continue;
     }
     const fileContent = await fs4.readFile(filePath, "utf8");
@@ -1170,17 +1236,15 @@ function printDiff(diff3) {
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync5, promises as fs8 } from "node:fs";
+import { existsSync as existsSync6, promises as fs8 } from "node:fs";
 import process5 from "node:process";
 import path14 from "pathe";
 import { Command as Command3 } from "commander";
 import { template } from "lodash-es";
 import ora2 from "ora";
 import prompts2 from "prompts";
-import { addDependency as addDependency2, addDevDependency as addDevDependency2, detectPackageManager as detectPackageManager2 } from "nypm";
 import { consola as consola5 } from "consola";
 import { colors as colors4 } from "consola/utils";
-import { execSync as execSync2 } from "node:child_process";
 
 // ../../node_modules/.pnpm/prettier@3.5.0/node_modules/prettier/index.mjs
 import { createRequire as __prettierCreateRequire } from "module";
@@ -1195,13 +1259,13 @@ import path42 from "path";
 import * as path32 from "path";
 import fs5 from "fs/promises";
 import path22 from "path";
-import * as path6 from "path";
+import * as path7 from "path";
 import path8 from "path";
 import fs22 from "fs/promises";
 import fs32 from "fs/promises";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import fs42 from "fs/promises";
-import path7 from "path";
+import path72 from "path";
 import { pathToFileURL as pathToFileURL4 } from "url";
 import assert3 from "assert";
 import { statSync, realpathSync } from "fs";
@@ -13700,15 +13764,15 @@ async function isDirectory(directory, options8) {
   return stats.isDirectory();
 }
 var is_directory_default = isDirectory;
-var toAbsolutePath = (value) => path6.resolve(toPath(value));
+var toAbsolutePath = (value) => path7.resolve(toPath(value));
 function* iterateDirectoryUp(from, to) {
   from = toAbsolutePath(from);
-  const { root: root2 } = path6.parse(from);
+  const { root: root2 } = path7.parse(from);
   to = to ? toAbsolutePath(to) : root2;
   if (from !== to && !from.startsWith(to)) {
     return;
   }
-  for (let directory = from; directory !== to; directory = path6.dirname(directory)) {
+  for (let directory = from; directory !== to; directory = path7.dirname(directory)) {
     yield directory;
   }
   yield to;
@@ -19062,7 +19126,7 @@ async function loadExternalConfig(externalConfig, configFile) {
 }
 var load_external_config_default = loadExternalConfig;
 async function loadConfig2(configFile) {
-  const { base: fileName, ext: extension } = path7.parse(configFile);
+  const { base: fileName, ext: extension } = path72.parse(configFile);
   const load2 = fileName === "package.json" ? loadConfigFromPackageJson : fileName === "package.yaml" ? loadConfigFromPackageYaml : loaders_default[extension];
   if (!load2) {
     throw new Error(
@@ -24085,59 +24149,86 @@ var src_default = index_exports;
 import { Project as Project2, SyntaxKind as SyntaxKind2 } from "ts-morph";
 
 // src/utils/get-project-info.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import path13 from "pathe";
 import fs7 from "fs-extra";
 import { readPackageJSON } from "pkg-types";
-async function getProjectInfo() {
-  const info = {
-    tsconfig: null,
-    isNuxt: false,
-    sigmaUiNuxtModuleInfo: void 0,
-    isVueVite: false,
-    srcDir: false,
-    componentsUiDir: false,
-    srcComponentsUiDir: false
+async function getProjectInfo(cwd = process.cwd()) {
+  const framework = detectFramework(cwd);
+  const tsConfigPath = detectTsConfigPath(cwd, framework);
+  const hasTailwind = await detectTailwind(cwd);
+  const { configType: tailwindConfigType, configPath: tailwindConfigPath } = detectTailwindConfigType(cwd);
+  const sigmaUiNuxtModuleInfo = framework === "nuxt" ? await getSigmaUiNuxtInfo() : void 0;
+  return {
+    framework,
+    tsConfigPath,
+    srcDir: existsSync5(path13.resolve(cwd, "src")),
+    srcComponentsUiDir: existsSync5(path13.resolve(cwd, "src/components/ui")),
+    componentsUiDir: existsSync5(path13.resolve(cwd, "components/ui")),
+    hasTailwind,
+    tailwindConfigType,
+    tailwindConfigPath,
+    sigmaUiNuxtModuleInfo
   };
-  try {
-    const tsconfig = await getTsConfig();
-    const isNuxt = existsSync4(path13.resolve("./nuxt.config.js")) || existsSync4(path13.resolve("./nuxt.config.ts"));
-    const sigmaUiNuxtModuleInfo = isNuxt ? await getSigmaUiNuxtInfo() : void 0;
-    return {
-      tsconfig,
-      isNuxt,
-      sigmaUiNuxtModuleInfo,
-      isVueVite: existsSync4(path13.resolve("./vite.config.js")) || existsSync4(path13.resolve("./vite.config.ts")),
-      srcDir: existsSync4(path13.resolve("./src")),
-      srcComponentsUiDir: existsSync4(path13.resolve("./src/components/ui")),
-      componentsUiDir: existsSync4(path13.resolve("./components/ui"))
-    };
-  } catch (error) {
-    console.log(error);
-    return info;
+}
+function detectTailwindConfigType(cwd) {
+  const jsConfigPaths = [
+    "tailwind.config.js",
+    "tailwind.config.ts",
+    "tailwind.config.mjs",
+    "tailwind.config.cjs"
+  ];
+  for (const configPath of jsConfigPaths) {
+    if (existsSync5(path13.resolve(cwd, configPath))) {
+      return { configType: "js", configPath };
+    }
   }
+  return { configType: "css", configPath: null };
 }
-async function getSigmaUiNuxtInfo() {
-  let nuxtModule;
+function detectFramework(cwd) {
+  if (existsSync5(path13.resolve(cwd, "nuxt.config.js")) || existsSync5(path13.resolve(cwd, "nuxt.config.ts"))) {
+    return "nuxt";
+  }
+  if (existsSync5(path13.resolve(cwd, "astro.config.mjs")) || existsSync5(path13.resolve(cwd, "astro.config.ts"))) {
+    return "astro";
+  }
+  if (existsSync5(path13.resolve(cwd, "artisan"))) {
+    return "laravel";
+  }
+  return "vite";
+}
+function detectTsConfigPath(cwd, framework) {
+  if (framework === "nuxt") {
+    return ".nuxt/tsconfig.json";
+  }
+  const possiblePaths = [
+    "tsconfig.json",
+    "tsconfig.app.json"
+  ];
+  for (const tsPath of possiblePaths) {
+    if (existsSync5(path13.resolve(cwd, tsPath))) {
+      return tsPath;
+    }
+  }
+  return "tsconfig.json";
+}
+async function detectTailwind(cwd) {
   try {
-    nuxtModule = await readPackageJSON("sigma-ui-nuxt");
-  } catch (error) {
-    console.log(error);
-    nuxtModule = void 0;
+    const packageJson = await readPackageJSON(cwd);
+    const allDeps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+    return "tailwindcss" in allDeps;
+  } catch {
+    return false;
   }
-  return nuxtModule;
 }
-async function getTsConfig() {
+async function getSigmaUiNuxtInfo() {
   try {
-    const tsconfigPath = path13.join("tsconfig.json");
-    const tsconfig = await fs7.readJSON(tsconfigPath);
-    if (!tsconfig) {
-      throw new Error("tsconfig.json is missing");
-    }
-    return tsconfig;
-  } catch (error) {
-    console.log(error);
-    return null;
+    return await readPackageJSON("sigma-ui-nuxt");
+  } catch {
+    return void 0;
   }
 }
 
@@ -24197,43 +24288,162 @@ function applyPrefixesCss(css, prefix) {
 }
 
 // ../shared/templates/tailwind-config.ts
-var TAILWIND_KEYFRAMES = `
-"fade-in": {
+var UTILS_TEMPLATE = `import { type ClassValue, clsx } from 'clsx'
+import { twMerge } from 'tailwind-merge'
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}
+`;
+var TAILWIND_V4_CSS_TEMPLATE = `@import "tailwindcss";
+
+@plugin "tailwindcss-animate";
+
+@custom-variant dark (&:is(.dark *));
+
+@theme inline {
+  --color-background: hsl(var(--background));
+  --color-foreground: hsl(var(--foreground));
+  --color-muted: hsl(var(--muted));
+  --color-muted-foreground: hsl(var(--muted-foreground));
+  --color-popover: hsl(var(--popover));
+  --color-popover-foreground: hsl(var(--popover-foreground));
+  --color-card: hsl(var(--card));
+  --color-card-foreground: hsl(var(--card-foreground));
+  --color-border: hsl(var(--border));
+  --color-input: hsl(var(--input));
+  --color-primary: hsl(var(--primary));
+  --color-primary-foreground: hsl(var(--primary-foreground));
+  --color-secondary: hsl(var(--secondary));
+  --color-secondary-foreground: hsl(var(--secondary-foreground));
+  --color-destructive: hsl(var(--destructive));
+  --color-destructive-foreground: hsl(var(--destructive-foreground));
+  --color-ring: hsl(var(--ring));
+
+  --radius-xl: calc(var(--radius) + 4px);
+  --radius-lg: var(--radius);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-sm: calc(var(--radius) - 4px);
+  --radius-xs: min(calc(var(--radius) / 2.5), 6px);
+
+  --animate-accordion-down: accordion-down 0.2s ease-out;
+  --animate-accordion-up: accordion-up 0.2s ease-out;
+  --animate-collapsible-down: collapsible-down 0.2s ease-in-out;
+  --animate-collapsible-up: collapsible-up 0.2s ease-in-out;
+
+  @keyframes accordion-down {
+    from {
+      height: 0;
+    }
+    to {
+      height: var(--reka-accordion-content-height);
+    }
+  }
+
+  @keyframes accordion-up {
+    from {
+      height: var(--reka-accordion-content-height);
+    }
+    to {
+      height: 0;
+    }
+  }
+
+  @keyframes collapsible-down {
+    from {
+      height: 0;
+    }
+    to {
+      height: var(--reka-collapsible-content-height);
+    }
+  }
+
+  @keyframes collapsible-up {
+    from {
+      height: var(--reka-collapsible-content-height);
+    }
+    to {
+      height: 0;
+    }
+  }
+}
+
+@layer base {
+  :root {
+    --backdrop-filter-blur: 32px;
+    --radius: 0.5rem;
+
+    <%- cssVarsLight %>
+  }
+ 
+  .dark {
+    <%- cssVarsDark %>
+  }
+
+  * {
+    @apply border-border;
+  }
+
+  body {
+    @apply bg-background text-foreground;
+  }
+}
+`;
+var TAILWIND_KEYFRAMES_JS = `
+"sigma-ui-fade-in": {
   from: { opacity: 0 },
   to: { opacity: 1 },
 },
-"accordion-down": {
+"sigma-ui-accordion-down": {
   from: { height: 0 },
   to: { height: "var(--reka-accordion-content-height)" },
 },
-"accordion-up": {
+"sigma-ui-accordion-up": {
   from: { height: "var(--reka-accordion-content-height)" },
   to: { height: 0 },
 },
-"collapsible-down": {
+"sigma-ui-collapsible-down": {
   from: { height: 0 },
-  to: { height: 'var(--reka-collapsible-content-height)' },
+  to: { height: "var(--reka-collapsible-content-height)" },
 },
-"collapsible-up": {
-  from: { height: 'var(--reka-collapsible-content-height)' },
+"sigma-ui-collapsible-up": {
+  from: { height: "var(--reka-collapsible-content-height)" },
   to: { height: 0 },
 },
+"sigma-ui-popover-slide-blur-from-top": {
+  from: { opacity: 0, transform: "translateY(-1rem) scaleY(0.98)", filter: "blur(4px)" },
+  to: { opacity: 1, transform: "translateY(0) scaleY(1)", filter: "blur(0px)" },
+},
+"sigma-ui-popover-slide-blur-from-bottom": {
+  from: { opacity: 0, transform: "translateY(1rem) scaleY(0.98)", filter: "blur(4px)" },
+  to: { opacity: 1, transform: "translateY(0) scaleY(1)", filter: "blur(0px)" },
+},
+"sigma-ui-popover-slide-blur-from-left": {
+  from: { opacity: 0, transform: "translateX(-1rem) scaleY(0.98)", filter: "blur(4px)" },
+  to: { opacity: 1, transform: "translateX(0) scaleY(1)", filter: "blur(0px)" },
+},
+"sigma-ui-popover-slide-blur-from-right": {
+  from: { opacity: 0, transform: "translateX(1rem) scaleY(0.98)", filter: "blur(4px)" },
+  to: { opacity: 1, transform: "translateX(0) scaleY(1)", filter: "blur(0px)" },
+},
+"sigma-ui-popover-fade-scale-blur-out": {
+  from: { opacity: 1, transform: "scaleY(1)", filter: "blur(0px)" },
+  to: { opacity: 0, transform: "scaleY(0.98)", filter: "blur(4px)" },
+},
 `;
-var TAILWIND_ANIMATION = `
-"fade-in": "fade-in 0.5s ease-in-out",
-"accordion-down": "accordion-down 0.2s ease-out",
-"accordion-up": "accordion-up 0.2s ease-out",
-"collapsible-down": "collapsible-down 0.2s ease-in-out",
-"collapsible-up": "collapsible-up 0.2s ease-in-out",
-`;
-var UTILS_TEMPLATE = `import { type ClassValue, clsx } from 'clsx'
-import { twMerge } from 'tailwind-merge'
-
-export function cn(...inputs: ClassValue[]) {
-  return twMerge(clsx(inputs))
-}
+var TAILWIND_ANIMATION_JS = `
+"fade-in": "sigma-ui-fade-in 0.5s ease-in-out",
+"accordion-down": "sigma-ui-accordion-down 0.2s ease-out",
+"accordion-up": "sigma-ui-accordion-up 0.2s ease-out",
+"collapsible-down": "sigma-ui-collapsible-down 0.2s ease-in-out",
+"collapsible-up": "sigma-ui-collapsible-up 0.2s ease-in-out",
+"popover-slide-blur-from-top": "sigma-ui-popover-slide-blur-from-top 150ms ease-out",
+"popover-slide-blur-from-bottom": "sigma-ui-popover-slide-blur-from-bottom 150ms ease-out",
+"popover-slide-blur-from-left": "sigma-ui-popover-slide-blur-from-left 150ms ease-out",
+"popover-slide-blur-from-right": "sigma-ui-popover-slide-blur-from-right 150ms ease-out",
+"popover-fade-scale-blur-out": "sigma-ui-popover-fade-scale-blur-out 150ms ease-in",
 `;
-var TAILWIND_CONFIG_TEMPLATE = `const animate = require("tailwindcss-animate")
+var TAILWIND_CONFIG_JS_TEMPLATE = `const animate = require("tailwindcss-animate")
 
 /** @type {import('tailwindcss').Config} */
 module.exports = {
@@ -24307,15 +24517,39 @@ module.exports = {
         xs: 'min(calc(var(--radius) / 2.5), 6px)',
       },
       keyframes: {
-        ${TAILWIND_KEYFRAMES}
+        ${TAILWIND_KEYFRAMES_JS}
       },
       animation: {
-        ${TAILWIND_ANIMATION}
+        ${TAILWIND_ANIMATION_JS}
       },
     },
   },
   plugins: [animate],
 }`;
+var TAILWIND_CSS_WITH_JS_CONFIG_TEMPLATE = `@import "tailwindcss";
+@config "<%- configPath %>";
+
+@layer base {
+  :root {
+    --backdrop-filter-blur: 32px;
+    --radius: 0.5rem;
+
+    <%- cssVarsLight %>
+  }
+ 
+  .dark {
+    <%- cssVarsDark %>
+  }
+
+  * {
+    @apply border-border;
+  }
+
+  body {
+    @apply bg-background text-foreground;
+  }
+}
+`;
 
 // ../shared/templates/preflight.ts
 var PREFLIGHT_CSS_TEMPLATE = `
@@ -24734,22 +24968,19 @@ var PROJECT_DEV_DEPENDENCIES = {
     ]
   }
 };
-var init = new Command3().name("init").description("initialize your project and install dependencies").option("-y, --yes", "skip confirmation prompt.", false).option(
+var init = new Command3().name("init").description("initialize your project and install dependencies").option("-y, --yes", "skip confirmation prompt.", false).option("-d, --defaults", "use default configuration without prompts.", false).option(
   "-c, --cwd <cwd>",
   "the working directory. defaults to the current directory.",
   process5.cwd()
 ).action(async (opts) => {
   try {
-    const spinner = ora2("Fetching data...").start();
     const options8 = initOptionsSchema.parse(opts);
     const cwd = path14.resolve(options8.cwd);
-    if (!existsSync5(cwd)) {
+    if (!existsSync6(cwd)) {
       consola5.error(`The path ${cwd} does not exist. Please try again.`);
       process5.exit(1);
     }
-    const existingConfig = await getConfig(cwd);
-    spinner.stop();
-    const config = await promptForConfig(cwd, existingConfig, options8.yes);
+    const config = await promptForConfig(cwd, options8.yes, options8.defaults);
     await runInit(cwd, config);
     consola5.log("");
     consola5.info(
@@ -24760,115 +24991,111 @@ var init = new Command3().name("init").description("initialize your project and
     handleError(error);
   }
 });
-async function promptForConfig(cwd, defaultConfig = null, skip2 = false) {
+function getDetectedConfig(projectInfo) {
+  const { framework, tsConfigPath, hasTailwind, tailwindConfigType, tailwindConfigPath } = projectInfo;
+  return {
+    framework,
+    tsConfigPath,
+    cssPath: TAILWIND_CSS_PATH[framework],
+    tailwindConfigPath: tailwindConfigPath ?? (framework === "astro" ? "tailwind.config.mjs" : DEFAULT_TAILWIND_CONFIG),
+    tailwindConfigType,
+    setupTailwind: !hasTailwind
+  };
+}
+async function promptForConfig(cwd, skipConfirmation = false, useDefaults = false) {
   const highlight = (text) => colors4.cyan(text);
+  const spinner = ora2("Detecting project settings...").start();
+  const projectInfo = await getProjectInfo(cwd);
+  const detectedConfig = getDetectedConfig(projectInfo);
   const styles3 = await getRegistryStyles();
   const baseColors2 = await getRegistryBaseColors();
+  spinner.stop();
+  consola5.info(`Detected ${highlight(detectedConfig.framework)} project`);
+  if (useDefaults) {
+    const config2 = createConfig({
+      framework: detectedConfig.framework,
+      styleSystem: "tailwind",
+      tailwindBaseColor: "grayscale",
+      componentNaming: "pascal-case",
+      tsConfigPath: detectedConfig.tsConfigPath,
+      cssPath: detectedConfig.cssPath,
+      tailwindConfigPath: detectedConfig.tailwindConfigPath,
+      tailwindConfigType: detectedConfig.tailwindConfigType,
+      setupTailwind: detectedConfig.setupTailwind,
+      components: DEFAULT_COMPONENTS,
+      utils: DEFAULT_UTILS,
+      generatePreflight: true
+    });
+    await writeConfigFile(cwd, config2);
+    return await resolveConfigPaths(cwd, config2);
+  }
   const options8 = await prompts2([
-    {
-      type: "select",
-      name: "framework",
-      message: `Which ${highlight("framework")} are you using?`,
-      choices: [
-        { title: "Vite", value: "vite" },
-        { title: "Nuxt", value: "nuxt" },
-        { title: "Laravel", value: "laravel" },
-        { title: "Astro", value: "astro" }
-      ]
-    },
     {
       type: "select",
       name: "styleSystem",
-      message: `Which ${highlight("style system")} are you using?`,
+      message: `Which ${highlight("style system")} would you like to use?`,
       choices: styles3.map((style) => ({
         title: style.label,
         value: style.name
       }))
     },
-    {
-      type: (_, answers) => answers.styleSystem === "tailwind" ? "toggle" : null,
-      name: "setupTailwind",
-      message: `Setup ${highlight("Tailwind")} in this project for you?`,
-      initial: !defaultConfig?.tailwind.config,
-      active: "yes",
-      inactive: "no"
-    },
     {
       type: "select",
       name: "tailwindBaseColor",
-      message: `Choose primary ${highlight("base color")}:`,
+      message: `Choose a ${highlight("base color")} for your theme:`,
       choices: baseColors2.map((color) => ({
         title: color.label,
         value: color.name
       }))
     },
     {
-      type: (_, answers) => answers.styleSystem === "tailwind" ? "text" : null,
-      name: "tailwindConfig",
-      message: `Specify the path to ${highlight("tailwind")} config file ${colors4.gray("(it will be overwritten / created)")}`,
-      initial: (_, answers) => {
-        if (defaultConfig?.tailwind.config) {
-          return defaultConfig?.tailwind.config;
-        }
-        if (answers.framework === "astro") {
-          return "tailwind.config.mjs";
-        } else {
-          return DEFAULT_TAILWIND_CONFIG;
-        }
-      }
-    },
-    {
-      type: "text",
-      name: "tsConfigPath",
-      message: `Specify the path to ${highlight("tsconfig")} file`,
-      initial: (_, values) => {
-        const prefix = values.framework === "nuxt" ? ".nuxt/" : "./";
-        return `${prefix}tsconfig.json`;
-      }
-    },
-    {
-      type: "text",
-      name: "cssPath",
-      message: `Specify the path to ${highlight("global CSS")} file ${colors4.gray("(it will be overwritten / created)")}`,
-      initial: (_, values) => defaultConfig?.cssPath ?? TAILWIND_CSS_PATH[values.framework]
-    },
-    {
-      type: "text",
-      name: "components",
-      message: `Configure the import alias for ${highlight("components")}:`,
-      initial: defaultConfig?.aliases.components ?? DEFAULT_COMPONENTS
-    },
-    {
-      type: (_, answers) => answers.styleSystem === "tailwind" ? "text" : null,
-      name: "utils",
-      message: `Configure the import alias for ${highlight("utils")}:`,
-      initial: defaultConfig?.aliases.utils ?? DEFAULT_UTILS
-    },
-    {
-      type: (_, answers) => answers.styleSystem === "css" ? "toggle" : null,
-      name: "generatePreflight",
-      message: `Generate ${highlight("preflight.css")} with modern CSS reset? ${colors4.gray("(recommended)")}`,
-      initial: true,
-      active: "yes",
-      inactive: "no"
+      type: "select",
+      name: "componentNaming",
+      message: `Choose ${highlight("component naming")} convention:`,
+      choices: [
+        { title: "PascalCase (Button.vue)", value: "pascal-case" },
+        { title: "kebab-case (button.vue)", value: "kebab-case" }
+      ],
+      initial: 0
     }
   ]);
-  if (!skip2) {
+  if (!skipConfirmation) {
+    consola5.log("");
+    consola5.box(
+      `Framework: ${highlight(detectedConfig.framework)}
+Style: ${highlight(options8.styleSystem)}
+Theme: ${highlight(options8.tailwindBaseColor)}
+Naming: ${highlight(options8.componentNaming)}
+CSS: ${highlight(detectedConfig.cssPath)}
+Components: ${highlight(DEFAULT_COMPONENTS)}`
+    );
     const { proceed } = await prompts2({
       type: "confirm",
       name: "proceed",
-      message: `Configuration is done. The config file will be created (${highlight(CONFIG_FILE_PATH)}) and the required dependencies will be installed. Make sure to handle any unstaged Git changes before proceeding. Finish setup?`,
+      message: "Proceed with installation?",
       initial: true
     });
     if (!proceed) {
       process5.exit(0);
     }
   }
-  const config = createConfig(options8);
+  const config = createConfig({
+    ...options8,
+    framework: detectedConfig.framework,
+    tsConfigPath: detectedConfig.tsConfigPath,
+    cssPath: detectedConfig.cssPath,
+    tailwindConfigPath: options8.styleSystem === "tailwind" ? detectedConfig.tailwindConfigPath : "",
+    tailwindConfigType: detectedConfig.tailwindConfigType,
+    setupTailwind: options8.styleSystem === "tailwind" ? detectedConfig.setupTailwind : false,
+    components: DEFAULT_COMPONENTS,
+    utils: DEFAULT_UTILS,
+    generatePreflight: options8.styleSystem === "css"
+  });
   await writeConfigFile(cwd, config);
   return await resolveConfigPaths(cwd, config);
 }
 function createConfig(options8) {
+  const usesJsConfig = options8.tailwindConfigType === "js";
   const config = rawConfigSchema.parse({
     $schema: "https://sigma-ui.dev/schema.json",
     styleSystem: options8.styleSystem,
@@ -24878,13 +25105,14 @@ function createConfig(options8) {
     cssPath: options8.cssPath,
     baseColor: options8.tailwindBaseColor,
     tailwind: {
-      config: options8.tailwindConfig || ""
+      config: usesJsConfig ? options8.tailwindConfigPath : ""
     },
     aliases: {
       utils: options8.utils || "",
       components: options8.components
     },
-    generatePreflight: options8.generatePreflight
+    generatePreflight: options8.generatePreflight,
+    componentNaming: options8.componentNaming || "pascal-case"
   });
   return config;
 }
@@ -24895,34 +25123,39 @@ async function writeConfigFile(cwd, config) {
   await fs8.writeFile(targetPath, JSON.stringify(config, null, 2), "utf8");
   spinner.succeed();
 }
-async function handleNuxtProject() {
-  const { isNuxt, sigmaUiNuxtModuleInfo } = await getProjectInfo();
-  if (isNuxt) {
+async function handleNuxtProject(cwd) {
+  const projectInfo = await getProjectInfo(cwd);
+  if (projectInfo.framework === "nuxt") {
     consola5.log("");
-    sigmaUiNuxtModuleInfo ? consola5.info(`Detected a Nuxt project with 'sigma-ui-nuxt' v${sigmaUiNuxtModuleInfo.version}`) : consola5.warn(`Detected a Nuxt project without 'sigma-ui-nuxt' module. It's recommended to install it.`);
+    if (projectInfo.sigmaUiNuxtModuleInfo) {
+      consola5.info(`Detected a Nuxt project with 'sigma-ui-nuxt' v${projectInfo.sigmaUiNuxtModuleInfo.version}`);
+    } else {
+      consola5.warn(`Detected a Nuxt project without 'sigma-ui-nuxt' module. It's recommended to install it.`);
+    }
   }
 }
 async function runInit(cwd, config) {
-  await writeFiles(config);
+  await writeFiles(config, cwd);
   await installDependencies2(config, cwd);
 }
-async function writeFiles(config) {
+async function writeFiles(config, cwd) {
   const writeFilesSpinner = ora2("Initializing project")?.start();
-  await handleNuxtProject();
+  await handleNuxtProject(cwd);
   await ensureDirectoriesExist(config);
-  if (config.tailwind.config) {
-    writeTailwindConfig(config);
-    if (config.framework === "vite" && config.setupTailwind) {
-      await updateViteConfig();
-    }
+  const hasJsConfig = Boolean(config.tailwind.config && config.tailwind.config.length > 0);
+  if (hasJsConfig) {
+    await writeTailwindJsConfig(config);
+  }
+  if (config.framework === "vite" && config.setupTailwind) {
+    await updateViteConfig();
   }
-  writeCssFile(config);
+  await writeCssFile(config, hasJsConfig);
   writeCnFile(config);
   await writePreflightCss(config);
   writeFilesSpinner?.succeed();
 }
-async function writeTailwindConfig(config) {
-  const unformattedConfig = template(TAILWIND_CONFIG_TEMPLATE)({
+async function writeTailwindJsConfig(config) {
+  const unformattedConfig = template(TAILWIND_CONFIG_JS_TEMPLATE)({
     framework: config.framework,
     prefix: config.tailwind.prefix,
     extension: "ts"
@@ -24943,23 +25176,47 @@ async function writeTailwindConfig(config) {
     "utf8"
   );
 }
-async function writeCssFile(config) {
+async function writeCssFile(config, hasJsConfig) {
   const baseColorData = await getRegistryBaseColor(config.baseColor);
-  if (baseColorData) {
-    const file = config.resolvedPaths.tailwindCss;
-    let data = "";
-    if (config.styleSystem === "tailwind") {
-      data = config.tailwind.prefix ? applyPrefixesCss(baseColorData.templates.tailwind.withVariables, config.tailwind.prefix) : baseColorData.templates.tailwind.withVariables;
-    } else if (config.styleSystem === "css") {
-      data = baseColorData.templates.css.withVariables;
-      if (config.generatePreflight) {
-        data = `@import "./preflight.css";
+  if (!baseColorData) {
+    return;
+  }
+  const file = config.resolvedPaths.tailwindCss;
+  let data = "";
+  if (config.styleSystem === "tailwind") {
+    const cssVarsLight = generateCssVars(baseColorData.cssVars.light);
+    const cssVarsDark = generateCssVars(baseColorData.cssVars.dark);
+    if (hasJsConfig) {
+      data = template(TAILWIND_CSS_WITH_JS_CONFIG_TEMPLATE)({
+        configPath: config.tailwind.config,
+        cssVarsLight,
+        cssVarsDark
+      });
+    } else {
+      data = template(TAILWIND_V4_CSS_TEMPLATE)({
+        cssVarsLight,
+        cssVarsDark
+      });
+    }
+    if (config.tailwind.prefix) {
+      data = applyPrefixesCss(data, config.tailwind.prefix);
+    }
+  } else if (config.styleSystem === "css") {
+    data = baseColorData.templates.css.withVariables;
+    if (config.generatePreflight) {
+      data = `@import "./preflight.css";
 
 ${data}`;
-      }
     }
-    await fs8.writeFile(file, data, "utf8");
   }
+  const formattedCss = await src_default.format(data, {
+    parser: "css",
+    singleQuote: true
+  });
+  await fs8.writeFile(file, formattedCss, "utf8");
+}
+function generateCssVars(vars) {
+  return Object.entries(vars).map(([key2, value]) => `--${key2}: ${value};`).join("\n    ");
 }
 async function writeCnFile(config) {
   if (config.resolvedPaths.utils) {
@@ -24981,11 +25238,11 @@ async function writePreflightCss(config) {
   }
 }
 async function installDependencies2(config, cwd) {
-  const { sigmaUiNuxtModuleInfo } = await getProjectInfo();
+  const projectInfo = await getProjectInfo(cwd);
   const dependenciesSpinner = ora2("Installing dependencies")?.start();
   let baseDeps = [];
   let baseDevDeps = [];
-  if (sigmaUiNuxtModuleInfo?.version) {
+  if (projectInfo.sigmaUiNuxtModuleInfo?.version) {
     baseDeps = [];
   } else {
     if (config.styleSystem === "css") {
@@ -25000,50 +25257,17 @@ async function installDependencies2(config, cwd) {
   const deps = [...baseDeps, ...PROJECT_DEPENDENCIES.sharedBase].filter(Boolean);
   const devDeps = baseDevDeps.filter(Boolean);
   const installTasks = [
-    config.framework === "nuxt" && PROJECT_DEPENDENCIES.nuxt.length && { type: "devDependencies", deps: PROJECT_DEPENDENCIES.nuxt, installer: addDevDependency2 },
-    deps.length && { type: "dependencies", deps, installer: addDependency2 },
-    devDeps.length && { type: "devDependencies", deps: devDeps, installer: addDevDependency2 }
+    config.framework === "nuxt" && PROJECT_DEPENDENCIES.nuxt.length && { type: "devDependencies", deps: PROJECT_DEPENDENCIES.nuxt, installer: addDevDependency },
+    deps.length && { type: "dependencies", deps, installer: addDependency },
+    devDeps.length && { type: "devDependencies", deps: devDeps, installer: addDevDependency }
   ].filter(Boolean);
   for (const task of installTasks) {
     try {
       dependenciesSpinner.text = `Installing ${task.type}...`;
       await task.installer(task.deps, { cwd, silent: true });
     } catch (error) {
-      consola5.warn(`nypm failed to install ${task.type}:`, error);
-      const isCorepackError = error instanceof Error && error.message?.includes("corepack");
-      if (isCorepackError) {
-        consola5.info(`Falling back to direct package manager execution for ${task.type}...`);
-        const pm = await detectPackageManager2(cwd);
-        let command = "";
-        const depsString = task.deps.join(" ");
-        const devFlag = task.type === "devDependencies" ? "-D " : "";
-        switch (pm?.name) {
-          case "npm":
-            command = `npm install ${devFlag}${depsString}`;
-            break;
-          case "yarn":
-            command = `yarn add ${devFlag}${depsString}`;
-            break;
-          case "bun":
-            command = `bun add ${devFlag}${depsString}`;
-            break;
-          case "pnpm":
-          default:
-            command = `pnpm add ${devFlag}${depsString}`;
-            break;
-        }
-        try {
-          consola5.info(`Running: ${command}`);
-          execSync2(command, { cwd, stdio: "inherit" });
-          consola5.success(`Successfully installed ${task.type} using direct package manager execution.`);
-        } catch (fallbackError) {
-          const errorMessage = fallbackError instanceof Error ? fallbackError.message : "Unknown error";
-          consola5.error(`Fallback package manager execution failed for ${task.type}:`, errorMessage);
-        }
-      } else {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        consola5.error(`Failed to install ${task.type} using nypm: ${errorMessage}`);
-      }
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      consola5.error(`Failed to install ${task.type}: ${errorMessage}`);
     }
   }
   dependenciesSpinner?.succeed();
@@ -25075,7 +25299,7 @@ async function getDirectoryPath(key2, resolvedPath) {
 }
 async function updateViteConfig() {
   const viteConfigPath = path14.join(process5.cwd(), "vite.config.ts");
-  if (!existsSync5(viteConfigPath)) {
+  if (!existsSync6(viteConfigPath)) {
     consola5.warn(`Vite config file not found at ${viteConfigPath}`);
     return;
   }