stera-ui 0.6.0 → 0.7.0

package/dist/{chunk-SIXUH4HI.js → chunk-V4TMOT6I.js}

@@ -255,43 +255,15 @@ function detectAliasPrefix(cwd) {
   return first ? first.replace(/\/\*$/, "") : null;
 }
 
-// src/utils/write-stera-css.ts
-import fs3 from "fs/promises";
-import path4 from "path";
-function stripImportLines(content) {
-  const lines = content.split("\n");
-  const imports = [];
-  const kept = [];
-  for (const line of lines) {
-    if (line.trim().match(/^@import\s+["'].+["']/)) {
-      if (!line.trim().match(/^@import\s+["']tailwindcss["']/)) {
-        imports.push(line.trim());
-      }
-    } else {
-      kept.push(line);
-    }
-  }
-  return { content: kept.join("\n"), imports };
-}
-async function writeSteraUiCss(config, cwd) {
-  const item = await fetchRegistryItem("globals");
-  const rawContent = item.files?.[0]?.content ?? "";
-  const { content, imports } = stripImportLines(rawContent);
-  const cssDir = path4.dirname(path4.resolve(cwd, config.css));
-  const steraUiPath = path4.join(cssDir, "stera-ui.css");
-  await fs3.mkdir(cssDir, { recursive: true });
-  await fs3.writeFile(steraUiPath, content, "utf-8");
-  return {
-    steraUiPath,
-    extraImports: imports,
-    dependencies: item.dependencies ?? []
-  };
-}
+// src/utils/write-styles.ts
+import fs6 from "fs/promises";
+import { existsSync } from "fs";
+import path5 from "path";
 
 // src/utils/css-imports.ts
-import fs4 from "fs/promises";
+import fs3 from "fs/promises";
 async function insertImportLine(filePath, importStatement) {
-  const content = await fs4.readFile(filePath, "utf-8");
+  const content = await fs3.readFile(filePath, "utf-8");
   const importPath = importStatement.match(/["']([^"']+)["']/)?.[1];
   if (importPath) {
     const escaped = importPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -309,12 +281,147 @@ async function insertImportLine(filePath, importStatement) {
   } else {
     lines.unshift(importStatement);
   }
-  await fs4.writeFile(filePath, lines.join("\n"), "utf-8");
+  await fs3.writeFile(filePath, lines.join("\n"), "utf-8");
 }
 
-// src/utils/install-deps.ts
+// src/utils/patch-css-vars.ts
+import fs4 from "fs";
+function removeCssImport(filePath, importPath) {
+  const content = fs4.readFileSync(filePath, "utf-8");
+  const pattern = new RegExp(
+    `@import\\s+['"]${escapeRegex(importPath)}['"]\\s*;?\\n?`
+  );
+  if (!pattern.test(content)) return false;
+  fs4.writeFileSync(filePath, content.replace(pattern, ""), "utf-8");
+  return true;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/utils/write-files.ts
 import fs5 from "fs";
-import path5 from "path";
+import path4 from "path";
+import { confirm } from "@inquirer/prompts";
+async function confirmOverwrite(relativePath) {
+  if (!process.stdin.isTTY) {
+    console.log(
+      `  Skipping ${relativePath} (already exists, use --overwrite to replace)`
+    );
+    return false;
+  }
+  return confirm({
+    message: `${relativePath} already exists. Overwrite?`,
+    default: false
+  });
+}
+async function writeComponentFiles(items, config, projectRoot, options = {}) {
+  const written = [];
+  const skipped = [];
+  for (const item of items) {
+    for (const file of item.files ?? []) {
+      const outputPath = resolveOutputPath(config, projectRoot, file);
+      const relativePath = path4.relative(projectRoot, outputPath);
+      if (fs5.existsSync(outputPath)) {
+        const existing = fs5.readFileSync(outputPath, "utf-8");
+        if (existing === file.content) {
+          skipped.push({ path: relativePath, reason: "unchanged" });
+          continue;
+        }
+        if (!options.overwrite) {
+          const confirmed = await confirmOverwrite(relativePath);
+          if (!confirmed) {
+            skipped.push({ path: relativePath, reason: "declined" });
+            continue;
+          }
+        }
+      }
+      const dir = path4.dirname(outputPath);
+      fs5.mkdirSync(dir, { recursive: true });
+      fs5.writeFileSync(outputPath, file.content ?? "", "utf-8");
+      written.push(relativePath);
+    }
+  }
+  return { written, skipped };
+}
+
+// src/utils/write-styles.ts
+var INDEX_TARGET = "ui/index.css";
+var TYPOGRAPHY_TARGET = "ui/typography.css";
+var PROTECTED_TARGETS = /* @__PURE__ */ new Set([TYPOGRAPHY_TARGET, "ui/colors.css"]);
+var LEGACY_FILENAME = "stera-ui.css";
+var LEGACY_IMPORT = "./stera-ui.css";
+function partitionImports(content) {
+  const lines = content.split("\n");
+  const hoisted = [];
+  const kept = [];
+  for (const line of lines) {
+    const specifier = line.trim().match(/^@import\s+["'](.+?)["']/)?.[1];
+    if (specifier === void 0) {
+      kept.push(line);
+    } else if (specifier.startsWith("./") || specifier.startsWith("../")) {
+      kept.push(line);
+    } else if (specifier !== "tailwindcss") {
+      hoisted.push(line.trim());
+    }
+  }
+  const cleaned = kept.join("\n").replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "");
+  return { content: cleaned, hoisted };
+}
+async function migrateLegacyStyles(config, cwd) {
+  const globalsPath = path5.resolve(cwd, config.css);
+  const legacyPath = path5.join(path5.dirname(globalsPath), LEGACY_FILENAME);
+  if (!existsSync(legacyPath)) return null;
+  await fs6.rm(legacyPath);
+  if (existsSync(globalsPath)) {
+    removeCssImport(globalsPath, LEGACY_IMPORT);
+    await insertImportLine(globalsPath, `@import "./${INDEX_TARGET}";`);
+  }
+  return legacyPath;
+}
+async function writeStyles(config, cwd, options = {}) {
+  const item = await fetchRegistryItem("globals");
+  const cssDir = path5.dirname(path5.resolve(cwd, config.css));
+  const written = [];
+  const skipped = [];
+  let extraImports = [];
+  for (const file of item.files ?? []) {
+    const target = file.target ?? path5.basename(file.path);
+    const outputPath = path5.join(cssDir, target);
+    let content = file.content ?? "";
+    if (target === INDEX_TARGET) {
+      const partitioned = partitionImports(content);
+      content = partitioned.content;
+      extraImports = partitioned.hoisted;
+    }
+    if (PROTECTED_TARGETS.has(target) && existsSync(outputPath)) {
+      const existing = await fs6.readFile(outputPath, "utf-8");
+      if (existing === content) {
+        skipped.push({ path: target, reason: "unchanged" });
+        continue;
+      }
+      if (!options.overwrite && !await confirmOverwrite(target)) {
+        skipped.push({ path: target, reason: "declined" });
+        continue;
+      }
+    }
+    await fs6.mkdir(path5.dirname(outputPath), { recursive: true });
+    await fs6.writeFile(outputPath, content, "utf-8");
+    written.push(target);
+  }
+  return {
+    indexPath: path5.join(cssDir, INDEX_TARGET),
+    typographyPath: path5.join(cssDir, TYPOGRAPHY_TARGET),
+    extraImports,
+    dependencies: item.dependencies ?? [],
+    written,
+    skipped
+  };
+}
+
+// src/utils/install-deps.ts
+import fs7 from "fs";
+import path6 from "path";
 import { detect } from "@antfu/ni";
 import { execa } from "execa";
 
@@ -400,11 +507,11 @@ function getInstallArgs(pm, deps) {
 }
 async function installDependencies(deps, cwd) {
   if (deps.length === 0) return;
-  const pkgPath = path5.join(cwd, "package.json");
+  const pkgPath = path6.join(cwd, "package.json");
   let existing = /* @__PURE__ */ new Set();
-  if (fs5.existsSync(pkgPath)) {
+  if (fs7.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
       existing = new Set(
         Object.keys({ ...pkg.dependencies, ...pkg.devDependencies })
       );
@@ -432,54 +539,8 @@ or use "pnpm add -w <package>" manually to install at the root.`
   }
 }
 
-// src/utils/write-files.ts
-import fs6 from "fs";
-import path6 from "path";
-import { confirm } from "@inquirer/prompts";
-async function confirmOverwrite(relativePath) {
-  if (!process.stdin.isTTY) {
-    console.log(
-      `  Skipping ${relativePath} (already exists, use --overwrite to replace)`
-    );
-    return false;
-  }
-  return confirm({
-    message: `${relativePath} already exists. Overwrite?`,
-    default: false
-  });
-}
-async function writeComponentFiles(items, config, projectRoot, options = {}) {
-  const written = [];
-  const skipped = [];
-  for (const item of items) {
-    for (const file of item.files ?? []) {
-      const outputPath = resolveOutputPath(config, projectRoot, file);
-      const relativePath = path6.relative(projectRoot, outputPath);
-      if (fs6.existsSync(outputPath)) {
-        const existing = fs6.readFileSync(outputPath, "utf-8");
-        if (existing === file.content) {
-          skipped.push({ path: relativePath, reason: "unchanged" });
-          continue;
-        }
-        if (!options.overwrite) {
-          const confirmed = await confirmOverwrite(relativePath);
-          if (!confirmed) {
-            skipped.push({ path: relativePath, reason: "declined" });
-            continue;
-          }
-        }
-      }
-      const dir = path6.dirname(outputPath);
-      fs6.mkdirSync(dir, { recursive: true });
-      fs6.writeFileSync(outputPath, file.content ?? "", "utf-8");
-      written.push(relativePath);
-    }
-  }
-  return { written, skipped };
-}
-
 // src/utils/update-fonts.ts
-import { existsSync, promises as fs7 } from "fs";
+import { existsSync as existsSync2, promises as fs8 } from "fs";
 import path7 from "path";
 import {
   Project,
@@ -520,10 +581,10 @@ async function updateFonts(fonts, project, cwd, options = {}) {
   if (!layoutPath) return;
   if (options.silent) {
     try {
-      const layoutContent = await fs7.readFile(layoutPath, "utf-8");
+      const layoutContent = await fs8.readFile(layoutPath, "utf-8");
       const updatedContent = transformLayoutFonts(layoutContent, fonts);
       if (updatedContent !== layoutContent) {
-        await fs7.writeFile(layoutPath, updatedContent, "utf-8");
+        await fs8.writeFile(layoutPath, updatedContent, "utf-8");
       }
     } catch {
     }
@@ -531,10 +592,10 @@ async function updateFonts(fonts, project, cwd, options = {}) {
   }
   const spinner = createSpinner("Updating fonts");
   try {
-    const layoutContent = await fs7.readFile(layoutPath, "utf-8");
+    const layoutContent = await fs8.readFile(layoutPath, "utf-8");
     const updatedContent = transformLayoutFonts(layoutContent, fonts);
     if (updatedContent !== layoutContent) {
-      await fs7.writeFile(layoutPath, updatedContent, "utf-8");
+      await fs8.writeFile(layoutPath, updatedContent, "utf-8");
     }
     spinner.succeed("Updated layout with font imports");
   } catch {
@@ -544,7 +605,7 @@ async function updateFonts(fonts, project, cwd, options = {}) {
 function findLayoutFile(project, cwd) {
   if (!project.layoutFile) return null;
   const fullPath = path7.join(cwd, project.layoutFile);
-  return existsSync(fullPath) ? fullPath : null;
+  return existsSync2(fullPath) ? fullPath : null;
 }
 function transformLayoutFonts(input, fonts) {
   const project = new Project({ compilerOptions: {} });
@@ -799,8 +860,12 @@ export {
   loadConfig2 as loadConfig,
   detectProject,
   detectAliasPrefix,
-  writeSteraUiCss,
   insertImportLine,
+  writeComponentFiles,
+  INDEX_TARGET,
+  TYPOGRAPHY_TARGET,
+  migrateLegacyStyles,
+  writeStyles,
   brand,
   dim,
   LOGO,
@@ -810,7 +875,6 @@ export {
   createSpinner,
   detectPackageManager,
   installDependencies,
-  writeComponentFiles,
   massageTreeForFonts,
   updateFonts
 };

package/dist/cli.js

@@ -10,11 +10,11 @@ var pkg = createRequire(import.meta.url)("../package.json");
 var program = new Command();
 program.name("stera-ui").description("Add Stera UI components to your project.").version(pkg.version);
 program.command("init").description("Initialize Stera UI in your project.").option("-c, --cwd <path>", "Working directory", process.cwd()).option("-y, --yes", "Skip confirmation prompts").action(async (options) => {
-  const { init } = await import("./init-E7O5WAUI.js");
+  const { init } = await import("./init-QYYCGWYV.js");
   await init(options);
 });
 program.command("add").description("Add components to your project.").argument("<components...>", "Components to add").option("-c, --cwd <path>", "Working directory", process.cwd()).option("-y, --yes", "Skip confirmation prompts").option("-o, --overwrite", "Overwrite existing files without prompting").action(async (components, options) => {
-  const { add } = await import("./add-JUBSRCDJ.js");
+  const { add } = await import("./add-WUTTJN25.js");
   await add(components, options);
 });
 program.command("list").description("List all available components.").action(async () => {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { ComponentNotFoundError, fetchRegistryIndex, fetchRegistryItem, getAllComponents, getComponent, resolveDependencies } from './registry/index.js';
 export { RegistryFontItem, RegistryIndex, RegistryIndexEntry, RegistryItem, RegistryItemFile, RegistryItemFont, RegistryItemType, SteraConfig, configSchema, registryIndexEntrySchema, registryIndexSchema, registryItemFileSchema, registryItemFontSchema, registryItemSchema, registryItemTypeSchema } from './schema/index.js';
-export { CHECK, CONFIG_FILE, CROSS, LEGACY_CONFIG_FILE, LOGO, ProjectInfo, SkippedFile, TransformContext, TransformFn, WARN, WriteOptions, WriteResult, WriteSteraCssResult, applyTransforms, brand, createSpinner, detectAliasPrefix, detectPackageManager, detectProject, dim, findConfigPath, insertImportLine, installDependencies, loadConfig, massageTreeForFonts, resolveOutputPath, transformImports, updateFonts, writeComponentFiles, writeSteraUiCss } from './utils/index.js';
+export { CHECK, CONFIG_FILE, CROSS, INDEX_TARGET, LEGACY_CONFIG_FILE, LOGO, ProjectInfo, SkippedFile, TYPOGRAPHY_TARGET, TransformContext, TransformFn, WARN, WriteOptions, WriteResult, WriteStylesResult, applyTransforms, brand, createSpinner, detectAliasPrefix, detectPackageManager, detectProject, dim, findConfigPath, insertImportLine, installDependencies, loadConfig, massageTreeForFonts, migrateLegacyStyles, resolveOutputPath, transformImports, updateFonts, writeComponentFiles, writeStyles } from './utils/index.js';
 import 'zod';

package/dist/index.js

@@ -2,8 +2,10 @@ import {
   CHECK,
   CONFIG_FILE,
   CROSS,
+  INDEX_TARGET,
   LEGACY_CONFIG_FILE,
   LOGO,
+  TYPOGRAPHY_TARGET,
   WARN,
   applyTransforms,
   brand,
@@ -17,12 +19,13 @@ import {
   installDependencies,
   loadConfig,
   massageTreeForFonts,
+  migrateLegacyStyles,
   resolveOutputPath,
   transformImports,
   updateFonts,
   writeComponentFiles,
-  writeSteraUiCss
-} from "./chunk-SIXUH4HI.js";
+  writeStyles
+} from "./chunk-V4TMOT6I.js";
 import {
   ComponentNotFoundError,
   fetchRegistryIndex,
@@ -45,8 +48,10 @@ export {
   CONFIG_FILE,
   CROSS,
   ComponentNotFoundError,
+  INDEX_TARGET,
   LEGACY_CONFIG_FILE,
   LOGO,
+  TYPOGRAPHY_TARGET,
   WARN,
   applyTransforms,
   brand,
@@ -65,6 +70,7 @@ export {
   installDependencies,
   loadConfig,
   massageTreeForFonts,
+  migrateLegacyStyles,
   registryIndexEntrySchema,
   registryIndexSchema,
   registryItemFileSchema,
@@ -76,5 +82,5 @@ export {
   transformImports,
   updateFonts,
   writeComponentFiles,
-  writeSteraUiCss
+  writeStyles
 };

package/dist/{init-E7O5WAUI.js → init-QYYCGWYV.js}

@@ -2,10 +2,14 @@
 import {
   CONFIG_FILE,
   LEGACY_CONFIG_FILE,
+  TYPOGRAPHY_TARGET,
   findConfigPath,
+  insertImportLine,
   installDependencies,
-  writeSteraUiCss
-} from "./chunk-2Y64FOD3.js";
+  migrateLegacyStyles,
+  patchCssVariables,
+  writeStyles
+} from "./chunk-5NLD52O5.js";
 import {
   createSpinner,
   fetchRegistryItem
@@ -17,7 +21,7 @@ import {
 } from "./chunk-KGMF6UW4.js";
 
 // src/commands/init.ts
-import fs6 from "fs";
+import fs4 from "fs";
 import fsp from "fs/promises";
 import path4 from "path";
 import { confirm, select } from "@inquirer/prompts";
@@ -192,36 +196,8 @@ function detectFonts(cwd, project) {
   return result;
 }
 
-// src/utils/patch-css-vars.ts
-import fs3 from "fs";
-function patchCssVariables(filePath, patches) {
-  const content = fs3.readFileSync(filePath, "utf-8");
-  const lines = content.split("\n");
-  const patched = [];
-  const compiled = Object.entries(patches).map(([prop, newValue]) => ({
-    prop,
-    newValue,
-    regex: new RegExp(`(\\s*${escapeRegex(prop)}:\\s*).+?(;)`)
-  }));
-  for (let i = 0; i < lines.length; i++) {
-    for (const { prop, newValue, regex } of compiled) {
-      if (regex.test(lines[i])) {
-        lines[i] = lines[i].replace(regex, `$1${newValue}$2`);
-        if (!patched.includes(prop)) patched.push(prop);
-      }
-    }
-  }
-  if (patched.length > 0) {
-    fs3.writeFileSync(filePath, lines.join("\n"), "utf-8");
-  }
-  return patched;
-}
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 // src/utils/update-fonts.ts
-import { existsSync, promises as fs4 } from "fs";
+import { existsSync, promises as fs3 } from "fs";
 import path3 from "path";
 import {
   Project,
@@ -262,10 +238,10 @@ async function updateFonts(fonts, project, cwd, options = {}) {
   if (!layoutPath) return;
   if (options.silent) {
     try {
-      const layoutContent = await fs4.readFile(layoutPath, "utf-8");
+      const layoutContent = await fs3.readFile(layoutPath, "utf-8");
       const updatedContent = transformLayoutFonts(layoutContent, fonts);
       if (updatedContent !== layoutContent) {
-        await fs4.writeFile(layoutPath, updatedContent, "utf-8");
+        await fs3.writeFile(layoutPath, updatedContent, "utf-8");
       }
     } catch {
     }
@@ -273,10 +249,10 @@ async function updateFonts(fonts, project, cwd, options = {}) {
   }
   const spinner = createSpinner("Updating fonts");
   try {
-    const layoutContent = await fs4.readFile(layoutPath, "utf-8");
+    const layoutContent = await fs3.readFile(layoutPath, "utf-8");
     const updatedContent = transformLayoutFonts(layoutContent, fonts);
     if (updatedContent !== layoutContent) {
-      await fs4.writeFile(layoutPath, updatedContent, "utf-8");
+      await fs3.writeFile(layoutPath, updatedContent, "utf-8");
     }
     spinner.succeed("Updated layout with font imports");
   } catch {
@@ -531,41 +507,14 @@ function parseTemplateLiteralToCnArgs(templateLiteral) {
   return [...staticArgs, ...variableArgs];
 }
 
-// src/utils/css-imports.ts
-import fs5 from "fs/promises";
-async function insertImportLine(filePath, importStatement) {
-  const content = await fs5.readFile(filePath, "utf-8");
-  const importPath = importStatement.match(/["']([^"']+)["']/)?.[1];
-  if (importPath) {
-    const escaped = importPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    if (new RegExp(`@import\\s+["']${escaped}["']`).test(content)) return;
-  }
-  const lines = content.split("\n");
-  let lastImportIndex = -1;
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].trim().startsWith("@import")) {
-      lastImportIndex = i;
-    }
-  }
-  if (lastImportIndex >= 0) {
-    lines.splice(lastImportIndex + 1, 0, importStatement);
-  } else {
-    lines.unshift(importStatement);
-  }
-  await fs5.writeFile(filePath, lines.join("\n"), "utf-8");
-}
-
 // src/commands/init.ts
 var DEFAULT_FONT_NAMES = ["font-geist", "font-geist-mono"];
+function resolveCssPath(project) {
+  if (project.existingCssFile) return project.existingCssFile;
+  return project.hasSrc ? "src/styles/globals.css" : "styles/globals.css";
+}
 function buildConfig(project, strategy, aliasPrefix) {
-  let cssPath;
-  if (project.existingCssFile) {
-    cssPath = project.existingCssFile;
-  } else if (project.hasSrc) {
-    cssPath = "src/styles/globals.css";
-  } else {
-    cssPath = "styles/globals.css";
-  }
+  const cssPath = resolveCssPath(project);
   return {
     $schema: "https://ui.stera.sh/schema.json",
     version: 1,
@@ -640,11 +589,11 @@ async function fetchDefaultFonts() {
 async function executeFontStrategy(strategy, project, detected, config, cwd) {
   if (strategy === "skip") return;
   const cssDir = path4.dirname(path4.resolve(cwd, config.css));
-  const steraUiPath = path4.join(cssDir, "stera-ui.css");
+  const typographyPath = path4.join(cssDir, TYPOGRAPHY_TARGET);
   if (strategy === "keep-existing") {
     const fontFamily = detected.fontFamilies.length > 0 ? detected.fontFamilies[0] : null;
     const fontValue = detected.nextFontVariable ? `var(${detected.nextFontVariable})` : fontFamily ?? "Geist";
-    const patched = patchCssVariables(steraUiPath, {
+    const patched = patchCssVariables(typographyPath, {
       "--font-heading": fontValue,
       "--font-sans": fontValue
     });
@@ -661,17 +610,17 @@ async function executeFontStrategy(strategy, project, detected, config, cwd) {
   }
   if (fontTree.cssImports.length > 0) {
     for (const importLine of fontTree.cssImports) {
-      await insertImportLine(steraUiPath, importLine);
+      await insertImportLine(typographyPath, importLine);
     }
     console.log(
-      `  ${CHECK}  Added font imports to ${path4.relative(cwd, steraUiPath)}`
+      `  ${CHECK}  Added font imports to ${path4.relative(cwd, typographyPath)}`
     );
   }
   if (Object.keys(fontTree.cssVars).length > 0) {
-    const patched = patchCssVariables(steraUiPath, fontTree.cssVars);
+    const patched = patchCssVariables(typographyPath, fontTree.cssVars);
     if (patched.length > 0) {
       console.log(
-        `  ${CHECK}  Updated font variables in ${path4.relative(cwd, steraUiPath)}`
+        `  ${CHECK}  Updated font variables in ${path4.relative(cwd, typographyPath)}`
       );
     }
   }
@@ -693,7 +642,7 @@ async function init(options) {
       });
       if (shouldRename) {
         const renamed = path4.join(path4.dirname(existing), CONFIG_FILE);
-        fs6.renameSync(existing, renamed);
+        fs4.renameSync(existing, renamed);
         console.log(`  ${CHECK}  Renamed to ${CONFIG_FILE}`);
         console.log('  Run "stera-ui add <component>" to add components.\n');
       } else {
@@ -709,7 +658,7 @@ async function init(options) {
     return;
   }
   const pkgPath = path4.join(cwd, "package.json");
-  if (!fs6.existsSync(pkgPath)) {
+  if (!fs4.existsSync(pkgPath)) {
     console.error(
       "  Error: No package.json found. Please run this in a project directory."
     );
@@ -738,29 +687,47 @@ async function init(options) {
 `);
   }
   const detectedFonts = detectFonts(cwd, project);
+  const uiDir = path4.join(path4.dirname(path4.resolve(cwd, resolveCssPath(project))), "ui");
+  if (fs4.existsSync(uiDir) && fs4.readdirSync(uiDir).length > 0) {
+    const relativeUiDir = path4.relative(cwd, uiDir);
+    console.log("");
+    console.log(`  ${relativeUiDir} already exists and is not empty.`);
+    const proceed = options.yes || process.stdin.isTTY && await confirm({
+      message: `Write the style partials into ${relativeUiDir}?`,
+      default: false
+    });
+    if (!proceed) {
+      console.log("");
+      console.log(
+        `  Aborted. Move ${relativeUiDir} aside, or point "css" in ${CONFIG_FILE} at a different stylesheet, then run init again.`
+      );
+      return;
+    }
+  }
   const strategy = await promptFontStrategy(detectedFonts, options.yes ?? false);
   const config = buildConfig(project, strategy, aliasPrefix);
   const configPath = path4.join(cwd, CONFIG_FILE);
-  fs6.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  fs4.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   console.log(`  ${CHECK}  Created ${CONFIG_FILE}`);
   const fetchSpinner = createSpinner("Fetching base styles");
-  let steraCssResult;
+  let stylesResult;
   try {
-    steraCssResult = await writeSteraUiCss(config, cwd);
+    await migrateLegacyStyles(config, cwd);
+    stylesResult = await writeStyles(config, cwd);
   } catch (err) {
     fetchSpinner.fail("Failed to fetch base styles");
     throw err;
   }
   fetchSpinner.succeed("Base styles resolved");
   console.log(
-    `  ${CHECK}  Created ${path4.relative(cwd, steraCssResult.steraUiPath)}`
+    `  ${CHECK}  Created ${path4.relative(cwd, stylesResult.indexPath)}`
   );
   const globalsPath = project.existingCssFile ? path4.resolve(cwd, project.existingCssFile) : path4.resolve(cwd, config.css);
-  if (fs6.existsSync(globalsPath)) {
-    for (const imp of steraCssResult.extraImports) {
+  if (fs4.existsSync(globalsPath)) {
+    for (const imp of stylesResult.extraImports) {
       await insertImportLine(globalsPath, imp);
     }
-    await insertImportLine(globalsPath, '@import "./stera-ui.css";');
+    await insertImportLine(globalsPath, '@import "./ui/index.css";');
     console.log(
       `  ${CHECK}  Added @import to ${path4.relative(cwd, globalsPath)}`
     );
@@ -768,15 +735,15 @@ async function init(options) {
     await fsp.mkdir(path4.dirname(globalsPath), { recursive: true });
     const scaffold = [
       '@import "tailwindcss";',
-      ...steraCssResult.extraImports,
-      '@import "./stera-ui.css";'
+      ...stylesResult.extraImports,
+      '@import "./ui/index.css";'
     ].join("\n") + "\n";
     await fsp.writeFile(globalsPath, scaffold, "utf-8");
     console.log(`  ${CHECK}  Created ${path4.relative(cwd, globalsPath)}`);
   }
   await executeFontStrategy(strategy, project, detectedFonts, config, cwd);
-  if (steraCssResult.dependencies.length > 0) {
-    const deps = [...new Set(steraCssResult.dependencies)].sort();
+  if (stylesResult.dependencies.length > 0) {
+    const deps = [...new Set(stylesResult.dependencies)].sort();
     console.log("");
     await installDependencies(deps, cwd);
   }