stera-ui 0.8.0 → 0.9.0

package/dist/init-QYYCGWYV.js

@@ -1,763 +0,0 @@
-#!/usr/bin/env node
-import {
-  CONFIG_FILE,
-  LEGACY_CONFIG_FILE,
-  TYPOGRAPHY_TARGET,
-  findConfigPath,
-  insertImportLine,
-  installDependencies,
-  migrateLegacyStyles,
-  patchCssVariables,
-  writeStyles
-} from "./chunk-5NLD52O5.js";
-import {
-  createSpinner,
-  fetchRegistryItem
-} from "./chunk-KKUJRJ2N.js";
-import {
-  CHECK,
-  LOGO,
-  dim
-} from "./chunk-KGMF6UW4.js";
-
-// src/commands/init.ts
-import fs4 from "fs";
-import fsp from "fs/promises";
-import path4 from "path";
-import { confirm, select } from "@inquirer/prompts";
-
-// src/utils/detect-project.ts
-import fs from "fs";
-import path from "path";
-import { loadConfig } from "tsconfig-paths";
-function hasFile(cwd, filenames) {
-  return filenames.some((f) => fs.existsSync(path.join(cwd, f)));
-}
-function findTailwindCssFile(cwd) {
-  const candidates = [
-    "src/app/globals.css",
-    "src/styles/globals.css",
-    "src/index.css",
-    "app/globals.css",
-    "styles/globals.css",
-    "index.css"
-  ];
-  for (const candidate of candidates) {
-    const fullPath = path.join(cwd, candidate);
-    if (!fs.existsSync(fullPath)) continue;
-    const content = fs.readFileSync(fullPath, "utf-8");
-    if (content.includes('@import "tailwindcss"') || content.includes("@import 'tailwindcss'") || content.includes("@tailwind base")) {
-      return candidate;
-    }
-  }
-  return null;
-}
-function detectProject(cwd) {
-  const hasSrc = fs.existsSync(path.join(cwd, "src"));
-  let framework = "other";
-  if (hasFile(cwd, ["next.config.ts", "next.config.js", "next.config.mjs"])) {
-    framework = "next";
-  } else if (hasFile(cwd, ["vite.config.ts", "vite.config.js", "vite.config.mjs"])) {
-    framework = "vite";
-  }
-  let rsc = false;
-  if (framework === "next") {
-    const appDir = hasSrc ? "src/app" : "app";
-    rsc = fs.existsSync(path.join(cwd, appDir));
-  }
-  const existingCssFile = findTailwindCssFile(cwd);
-  let layoutFile = null;
-  if (framework === "next") {
-    const appDir = hasSrc ? "src/app" : "app";
-    for (const ext of ["tsx", "jsx", "ts", "js"]) {
-      const candidate = `${appDir}/layout.${ext}`;
-      if (fs.existsSync(path.join(cwd, candidate))) {
-        layoutFile = candidate;
-        break;
-      }
-    }
-  } else if (framework === "vite") {
-    if (fs.existsSync(path.join(cwd, "index.html"))) {
-      layoutFile = "index.html";
-    }
-  }
-  return { hasSrc, framework, rsc, existingCssFile, layoutFile };
-}
-function detectAliasPrefix(cwd) {
-  let tsConfig;
-  try {
-    tsConfig = loadConfig(cwd);
-  } catch {
-    return null;
-  }
-  if (tsConfig.resultType !== "success" || Object.keys(tsConfig.paths).length === 0) {
-    return null;
-  }
-  for (const [alias, targets] of Object.entries(tsConfig.paths)) {
-    if (targets.includes("./*") || targets.includes("./src/*") || targets.includes("./app/*")) {
-      return alias.replace(/\/\*$/, "");
-    }
-  }
-  const first = Object.keys(tsConfig.paths)[0];
-  return first ? first.replace(/\/\*$/, "") : null;
-}
-
-// src/utils/detect-fonts.ts
-import fs2 from "fs";
-import path2 from "path";
-function readIfExists(filePath) {
-  try {
-    return fs2.readFileSync(filePath, "utf-8");
-  } catch {
-    return null;
-  }
-}
-function detectNextFont(layoutContent) {
-  const hasNextFont = /import.*from\s+['"]next\/font/.test(layoutContent) || /import.*from\s+['"]@next\/font/.test(layoutContent) || /import.*from\s+['"]geist\/font/.test(layoutContent);
-  let nextFontVariable = null;
-  const varMatch = layoutContent.match(/variable:\s*['"](--.+?)['"]/);
-  if (varMatch) {
-    nextFontVariable = varMatch[1];
-  }
-  return { hasNextFont, nextFontVariable };
-}
-function detectFontFace(cssContent) {
-  const hasFontFace = /@font-face\s*\{/.test(cssContent);
-  const fontFamilies = [];
-  const regex = /font-family:\s*['"]?([^'";}\n]+?)['"]?\s*;/g;
-  let match;
-  while ((match = regex.exec(cssContent)) !== null) {
-    const family = match[1].trim();
-    if (family && !fontFamilies.includes(family)) {
-      fontFamilies.push(family);
-    }
-  }
-  return { hasFontFace, fontFamilies };
-}
-function detectGoogleFonts(content) {
-  return content.includes("fonts.googleapis.com") || content.includes("fonts.gstatic.com");
-}
-function detectFonts(cwd, project) {
-  const result = {
-    hasNextFont: false,
-    hasFontFace: false,
-    hasGoogleFontsLink: false,
-    fontFamilies: [],
-    nextFontVariable: null
-  };
-  if (project.layoutFile) {
-    const layoutContent = readIfExists(path2.join(cwd, project.layoutFile));
-    if (layoutContent) {
-      const nextFontResult = detectNextFont(layoutContent);
-      result.hasNextFont = nextFontResult.hasNextFont;
-      result.nextFontVariable = nextFontResult.nextFontVariable;
-      if (detectGoogleFonts(layoutContent)) {
-        result.hasGoogleFontsLink = true;
-      }
-    }
-  }
-  if (project.existingCssFile) {
-    const cssContent = readIfExists(path2.join(cwd, project.existingCssFile));
-    if (cssContent) {
-      const fontFaceResult = detectFontFace(cssContent);
-      result.hasFontFace = fontFaceResult.hasFontFace;
-      result.fontFamilies.push(...fontFaceResult.fontFamilies);
-      if (detectGoogleFonts(cssContent)) {
-        result.hasGoogleFontsLink = true;
-      }
-      const importRegex = /@import\s+['"](.+?)['"]/g;
-      let importMatch;
-      while ((importMatch = importRegex.exec(cssContent)) !== null) {
-        const importPath = importMatch[1];
-        const resolvedPath = path2.join(
-          cwd,
-          path2.dirname(project.existingCssFile),
-          importPath
-        );
-        const importedContent = readIfExists(resolvedPath);
-        if (importedContent) {
-          const imported = detectFontFace(importedContent);
-          if (imported.hasFontFace) result.hasFontFace = true;
-          for (const family of imported.fontFamilies) {
-            if (!result.fontFamilies.includes(family)) {
-              result.fontFamilies.push(family);
-            }
-          }
-        }
-      }
-    }
-  }
-  for (const htmlFile of ["index.html", "src/index.html"]) {
-    const htmlContent = readIfExists(path2.join(cwd, htmlFile));
-    if (htmlContent && detectGoogleFonts(htmlContent)) {
-      result.hasGoogleFontsLink = true;
-    }
-  }
-  return result;
-}
-
-// src/utils/update-fonts.ts
-import { existsSync, promises as fs3 } from "fs";
-import path3 from "path";
-import {
-  Project,
-  ScriptKind,
-  SyntaxKind,
-  VariableDeclarationKind
-} from "ts-morph";
-var ROOT_FONT_VARIABLES = /* @__PURE__ */ new Set([
-  "--font-sans",
-  "--font-serif",
-  "--font-mono"
-]);
-function massageTreeForFonts(fonts, project) {
-  const result = {
-    cssVars: {},
-    dependencies: [],
-    cssImports: []
-  };
-  if (fonts.length === 0) return result;
-  const isNext = project.framework === "next";
-  for (const font of fonts) {
-    if (isNext) {
-      result.cssVars[font.font.variable] = `var(${font.font.variable})`;
-    } else {
-      const fontName = font.name.replace(/^font-/, "");
-      const fontSourceDep = font.font.dependency ?? `@fontsource-variable/${fontName}`;
-      result.dependencies.push(fontSourceDep);
-      result.cssImports.push(`@import "${fontSourceDep}";`);
-      result.cssVars[font.font.variable] = font.font.family;
-    }
-  }
-  return result;
-}
-async function updateFonts(fonts, project, cwd, options = {}) {
-  if (fonts.length === 0) return;
-  if (project.framework !== "next") return;
-  const layoutPath = findLayoutFile(project, cwd);
-  if (!layoutPath) return;
-  if (options.silent) {
-    try {
-      const layoutContent = await fs3.readFile(layoutPath, "utf-8");
-      const updatedContent = transformLayoutFonts(layoutContent, fonts);
-      if (updatedContent !== layoutContent) {
-        await fs3.writeFile(layoutPath, updatedContent, "utf-8");
-      }
-    } catch {
-    }
-    return;
-  }
-  const spinner = createSpinner("Updating fonts");
-  try {
-    const layoutContent = await fs3.readFile(layoutPath, "utf-8");
-    const updatedContent = transformLayoutFonts(layoutContent, fonts);
-    if (updatedContent !== layoutContent) {
-      await fs3.writeFile(layoutPath, updatedContent, "utf-8");
-    }
-    spinner.succeed("Updated layout with font imports");
-  } catch {
-    spinner.fail("Failed to update fonts");
-  }
-}
-function findLayoutFile(project, cwd) {
-  if (!project.layoutFile) return null;
-  const fullPath = path3.join(cwd, project.layoutFile);
-  return existsSync(fullPath) ? fullPath : null;
-}
-function transformLayoutFonts(input, fonts) {
-  const project = new Project({ compilerOptions: {} });
-  const sourceFile = project.createSourceFile("layout.tsx", input, {
-    scriptKind: ScriptKind.TSX
-  });
-  const googleFonts = fonts.filter((f) => f.font.provider === "google");
-  const fontVariableNames = [];
-  const fontUtilityClasses = [];
-  for (const font of googleFonts) {
-    const importName = font.font.import;
-    if (!importName) continue;
-    const existingImport = sourceFile.getImportDeclaration(
-      (decl) => decl.getModuleSpecifierValue() === "next/font/google"
-    );
-    let hasExistingImport = false;
-    if (existingImport) {
-      const namedImports = existingImport.getNamedImports();
-      hasExistingImport = namedImports.some(
-        (imp) => imp.getName() === importName
-      );
-      if (!hasExistingImport) {
-        existingImport.addNamedImport(importName);
-      }
-    } else {
-      sourceFile.addImportDeclaration({
-        moduleSpecifier: "next/font/google",
-        namedImports: [importName]
-      });
-    }
-    const varName = getFontVariableName(importName, font.font.variable);
-    const fontOptions = buildFontOptions(font);
-    const existingVarDecl = findFontVariableDeclaration(
-      sourceFile,
-      font.font.variable
-    );
-    if (hasExistingImport && !existingVarDecl && isRootFontVariable(font.font.variable)) {
-      continue;
-    }
-    if (existingVarDecl) {
-      existingVarDecl.setInitializer(`${importName}(${fontOptions})`);
-      if (existingVarDecl.getName() !== varName) {
-        existingVarDecl.rename(varName);
-      }
-    } else {
-      const insertPosition = findInsertPosition(sourceFile);
-      const statement = sourceFile.insertVariableStatement(insertPosition, {
-        declarationKind: VariableDeclarationKind.Const,
-        declarations: [
-          {
-            name: varName,
-            initializer: `${importName}(${fontOptions})`
-          }
-        ]
-      });
-      statement.appendWhitespace("\n");
-    }
-    fontVariableNames.push(varName);
-    if (shouldApplyFontUtilityToHtml(font)) {
-      fontUtilityClasses.push(font.font.variable.replace("--", ""));
-    }
-  }
-  const fontFamilyClasses = /* @__PURE__ */ new Set(["font-sans", "font-serif", "font-mono"]);
-  const lastFontFamilyClass = [...fontUtilityClasses].reverse().find((cls) => fontFamilyClasses.has(cls));
-  const filteredUtilityClasses = fontUtilityClasses.filter(
-    (cls) => !fontFamilyClasses.has(cls)
-  );
-  if (lastFontFamilyClass) {
-    filteredUtilityClasses.unshift(lastFontFamilyClass);
-  }
-  if (fontVariableNames.length > 0) {
-    updateHtmlClassName(sourceFile, fontVariableNames, filteredUtilityClasses);
-  }
-  return sourceFile.getFullText();
-}
-function buildFontOptions(font) {
-  const options = {};
-  if (font.font.subsets?.length) options.subsets = font.font.subsets;
-  if (font.font.weight?.length) options.weight = font.font.weight;
-  options.variable = font.font.variable;
-  return JSON.stringify(options).replace(/"([^"]+)":/g, "$1:").replace(/"/g, "'");
-}
-function isRootFontVariable(variable) {
-  return ROOT_FONT_VARIABLES.has(variable);
-}
-function shouldApplyFontUtilityToHtml(font) {
-  return !font.font.selector && isRootFontVariable(font.font.variable);
-}
-function getFontVariableName(importName, variable) {
-  const baseName = toCamelCase(importName);
-  if (isRootFontVariable(variable)) return baseName;
-  return `${baseName}${toPascalCase(variable.replace(/^--font-/, ""))}`;
-}
-function toCamelCase(str) {
-  return str.split("_").map(
-    (part, index) => index === 0 ? part.toLowerCase() : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()
-  ).join("");
-}
-function toPascalCase(str) {
-  return str.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function findFontVariableDeclaration(sourceFile, variable) {
-  for (const statement of sourceFile.getVariableStatements()) {
-    for (const declaration of statement.getDeclarations()) {
-      const initializer = declaration.getInitializer();
-      if (!initializer || initializer.getKind() !== SyntaxKind.CallExpression)
-        continue;
-      const args = initializer.getArguments();
-      if (args.length === 0) continue;
-      const argText = args[0].getText();
-      if (argText.includes("variable:") && argText.includes(variable)) {
-        return declaration;
-      }
-    }
-  }
-  return null;
-}
-function findInsertPosition(sourceFile) {
-  const imports = sourceFile.getImportDeclarations();
-  if (imports.length > 0) {
-    return imports[imports.length - 1].getChildIndex() + 1;
-  }
-  return 0;
-}
-function updateHtmlClassName(sourceFile, fontVariableNames, fontUtilityClasses) {
-  const jsxElements = sourceFile.getDescendantsOfKind(
-    SyntaxKind.JsxOpeningElement
-  );
-  for (const element of jsxElements) {
-    if (element.getTagNameNode().getText() !== "html") continue;
-    const newUtilityClasses = fontUtilityClasses.map((cls) => `"${cls}"`);
-    const newVarExpressions = fontVariableNames.map(
-      (name) => `${name}.variable`
-    );
-    const allNewArgs = [...newUtilityClasses, ...newVarExpressions];
-    const classNameAttr = element.getAttribute("className");
-    if (!classNameAttr) {
-      element.addAttribute({
-        name: "className",
-        initializer: `{cn(${allNewArgs.join(", ")})}`
-      });
-      ensureCnImport(sourceFile);
-      return;
-    }
-    if (classNameAttr.getKind() !== SyntaxKind.JsxAttribute) return;
-    const jsxAttr = classNameAttr.asKindOrThrow(SyntaxKind.JsxAttribute);
-    const initializer = jsxAttr.getInitializer();
-    if (!initializer) return;
-    if (initializer.getKind() === SyntaxKind.StringLiteral) {
-      const currentValue = initializer.getText().slice(1, -1);
-      ensureCnImport(sourceFile);
-      jsxAttr.setInitializer(
-        `{cn("${currentValue}", ${allNewArgs.join(", ")})}`
-      );
-    } else if (initializer.getKind() === SyntaxKind.JsxExpression) {
-      const jsxExpr = initializer.asKindOrThrow(SyntaxKind.JsxExpression);
-      const expr = jsxExpr.getExpression();
-      if (!expr) return;
-      const exprText = expr.getText();
-      if (exprText.startsWith("cn(")) {
-        const hasAllFontVars = newVarExpressions.every(
-          (v) => exprText.includes(v)
-        );
-        const hasAllUtilityClasses = fontUtilityClasses.every(
-          (cls) => exprText.includes(`"${cls}"`)
-        );
-        if (hasAllFontVars && hasAllUtilityClasses) continue;
-        let cleanedExpr = exprText;
-        for (const varExpr of newVarExpressions) {
-          cleanedExpr = cleanedExpr.replace(
-            new RegExp(`,?\\s*${varExpr.replace(".", "\\.")}`, "g"),
-            ""
-          );
-        }
-        cleanedExpr = cleanedExpr.replace(/cn\(\s*,/, "cn(");
-        const newExpr = cleanedExpr.replace(
-          /\)$/,
-          `, ${allNewArgs.join(", ")})`
-        );
-        jsxExpr.replaceWithText(`{${newExpr}}`);
-      } else if (/^\w+\.variable$/.test(exprText)) {
-        ensureCnImport(sourceFile);
-        jsxExpr.replaceWithText(`{cn(${allNewArgs.join(", ")})}`);
-      } else if (exprText.startsWith("`") && exprText.endsWith("`")) {
-        const cnArgs = parseTemplateLiteralToCnArgs(exprText);
-        ensureCnImport(sourceFile);
-        const allNewArgsSet = new Set(allNewArgs);
-        const fontFamilyLiterals = new Set(
-          ["font-sans", "font-serif", "font-mono"].map((c) => `"${c}"`)
-        );
-        const cleanedCnArgs = cnArgs.filter(
-          (arg) => !allNewArgsSet.has(arg) && !fontFamilyLiterals.has(arg)
-        );
-        jsxExpr.replaceWithText(
-          `{cn(${[...cleanedCnArgs, ...allNewArgs].join(", ")})}`
-        );
-      } else {
-        ensureCnImport(sourceFile);
-        jsxExpr.replaceWithText(`{cn(${exprText}, ${allNewArgs.join(", ")})}`);
-      }
-    }
-  }
-}
-function ensureCnImport(sourceFile) {
-  const existingImport = sourceFile.getImportDeclaration(
-    (decl) => decl.getNamedImports().some((imp) => imp.getName() === "cn")
-  );
-  if (!existingImport) {
-    const utilsImport = sourceFile.getImportDeclaration(
-      (decl) => decl.getModuleSpecifierValue().includes("/lib/utils")
-    );
-    if (utilsImport) {
-      const namedImports = utilsImport.getNamedImports();
-      if (!namedImports.some((imp) => imp.getName() === "cn")) {
-        utilsImport.addNamedImport("cn");
-      }
-    } else {
-      sourceFile.addImportDeclaration({
-        moduleSpecifier: "@/lib/utils",
-        namedImports: ["cn"]
-      });
-    }
-  }
-}
-function parseTemplateLiteralToCnArgs(templateLiteral) {
-  const staticArgs = [];
-  const variableArgs = [];
-  const content = templateLiteral.slice(1, -1);
-  const parts = content.split(/(\$\{[^}]+\})/);
-  for (const part of parts) {
-    if (!part) continue;
-    if (part.startsWith("${") && part.endsWith("}")) {
-      const expr = part.slice(2, -1).trim();
-      if (expr) variableArgs.push(expr);
-    } else {
-      const staticParts = part.trim().split(/\s+/).filter(Boolean);
-      for (const staticPart of staticParts) {
-        staticArgs.push(`"${staticPart}"`);
-      }
-    }
-  }
-  return [...staticArgs, ...variableArgs];
-}
-
-// 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) {
-  const cssPath = resolveCssPath(project);
-  return {
-    $schema: "https://ui.stera.sh/schema.json",
-    version: 1,
-    css: cssPath,
-    aliases: {
-      components: `${aliasPrefix}/components`,
-      utils: `${aliasPrefix}/lib/utils`,
-      ui: `${aliasPrefix}/components/ui`,
-      lib: `${aliasPrefix}/lib`,
-      hooks: `${aliasPrefix}/hooks`
-    },
-    fonts: {
-      strategy
-    }
-  };
-}
-async function promptFontStrategy(detected, skipPrompts) {
-  const hasExistingFonts = detected.hasNextFont || detected.hasFontFace || detected.hasGoogleFontsLink;
-  const defaultStrategy = hasExistingFonts ? "keep-existing" : "stera-default";
-  if (skipPrompts) return defaultStrategy;
-  if (hasExistingFonts) {
-    const sources = [];
-    if (detected.fontFamilies.length > 0) {
-      sources.push(detected.fontFamilies.join(", "));
-    }
-    if (detected.hasNextFont) sources.push("next/font");
-    if (detected.hasGoogleFontsLink) sources.push("Google Fonts");
-    console.log(`  Detected existing fonts: ${sources.join(" via ")}
-`);
-  }
-  const choices = [];
-  if (hasExistingFonts) {
-    choices.push({
-      value: "keep-existing",
-      name: "Keep my current fonts",
-      description: "Update CSS variables to use your existing fonts"
-    });
-  }
-  choices.push({
-    value: "stera-default",
-    name: "Use Stera UI default fonts (Geist Sans + Geist Mono)",
-    description: "Optimized variable fonts via next/font or fontsource"
-  });
-  choices.push({
-    value: "skip",
-    name: "Skip font setup",
-    description: "Configure fonts manually later"
-  });
-  const strategy = await select({
-    message: "How would you like to set up fonts?",
-    choices,
-    default: defaultStrategy
-  });
-  console.log("");
-  return strategy;
-}
-async function fetchDefaultFonts() {
-  const spinner = createSpinner("Fetching fonts");
-  const results = await Promise.all(
-    DEFAULT_FONT_NAMES.map(async (name) => {
-      try {
-        const item = await fetchRegistryItem(name);
-        return item.type === "registry:font" ? item : null;
-      } catch {
-        return null;
-      }
-    })
-  );
-  spinner.succeed("Fonts resolved");
-  return results.filter((item) => item !== null);
-}
-async function executeFontStrategy(strategy, project, detected, config, cwd) {
-  if (strategy === "skip") return;
-  const cssDir = path4.dirname(path4.resolve(cwd, config.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(typographyPath, {
-      "--font-heading": fontValue,
-      "--font-sans": fontValue
-    });
-    if (patched.length > 0) {
-      console.log(`  ${CHECK}  Updated font variables to use ${fontValue}`);
-    }
-    return;
-  }
-  const fonts = await fetchDefaultFonts();
-  if (fonts.length === 0) return;
-  const fontTree = massageTreeForFonts(fonts, project);
-  if (fontTree.dependencies.length > 0) {
-    await installDependencies(fontTree.dependencies, cwd);
-  }
-  if (fontTree.cssImports.length > 0) {
-    for (const importLine of fontTree.cssImports) {
-      await insertImportLine(typographyPath, importLine);
-    }
-    console.log(
-      `  ${CHECK}  Added font imports to ${path4.relative(cwd, typographyPath)}`
-    );
-  }
-  if (Object.keys(fontTree.cssVars).length > 0) {
-    const patched = patchCssVariables(typographyPath, fontTree.cssVars);
-    if (patched.length > 0) {
-      console.log(
-        `  ${CHECK}  Updated font variables in ${path4.relative(cwd, typographyPath)}`
-      );
-    }
-  }
-  await updateFonts(fonts, project, cwd);
-}
-async function init(options) {
-  const cwd = options.cwd ? path4.resolve(options.cwd) : process.cwd();
-  console.log(`
-  ${LOGO}  Stera UI
-`);
-  const existing = findConfigPath(cwd);
-  if (existing) {
-    const existingName = path4.basename(existing);
-    if (existingName === LEGACY_CONFIG_FILE) {
-      console.log(`  Found legacy ${LEGACY_CONFIG_FILE} at ${existing}`);
-      const shouldRename = options.yes ? true : await confirm({
-        message: `Rename it to ${CONFIG_FILE}?`,
-        default: true
-      });
-      if (shouldRename) {
-        const renamed = path4.join(path4.dirname(existing), CONFIG_FILE);
-        fs4.renameSync(existing, renamed);
-        console.log(`  ${CHECK}  Renamed to ${CONFIG_FILE}`);
-        console.log('  Run "stera-ui add <component>" to add components.\n');
-      } else {
-        console.log(
-          `  Keeping ${LEGACY_CONFIG_FILE} for now. Legacy filename support will be removed in a future release.
-`
-        );
-      }
-      return;
-    }
-    console.log(`  ${CONFIG_FILE} already exists at ${existing}`);
-    console.log('  Run "stera-ui add <component>" to add components.\n');
-    return;
-  }
-  const pkgPath = path4.join(cwd, "package.json");
-  if (!fs4.existsSync(pkgPath)) {
-    console.error(
-      "  Error: No package.json found. Please run this in a project directory."
-    );
-    process.exit(1);
-  }
-  const project = detectProject(cwd);
-  const aliasPrefix = detectAliasPrefix(cwd);
-  if (!aliasPrefix) {
-    console.error("");
-    console.error("  Error: No import alias found in your tsconfig.json file.");
-    console.error(
-      '  Stera UI requires a path alias (e.g. "@/*": ["./src/*"]) in compilerOptions.paths.'
-    );
-    console.error(
-      "  See https://ui.stera.sh/docs/installation for setup instructions per framework."
-    );
-    console.error("");
-    process.exit(1);
-  }
-  const frameworkName = project.framework === "next" ? "Next.js" : project.framework === "vite" ? "Vite" : null;
-  const parts = [];
-  if (frameworkName) parts.push(frameworkName);
-  if (project.hasSrc) parts.push("src/ directory");
-  if (parts.length > 0) {
-    console.log(`  Detected ${parts.join(" project with ")} project
-`);
-  }
-  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);
-  fs4.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-  console.log(`  ${CHECK}  Created ${CONFIG_FILE}`);
-  const fetchSpinner = createSpinner("Fetching base styles");
-  let stylesResult;
-  try {
-    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, stylesResult.indexPath)}`
-  );
-  const globalsPath = project.existingCssFile ? path4.resolve(cwd, project.existingCssFile) : path4.resolve(cwd, config.css);
-  if (fs4.existsSync(globalsPath)) {
-    for (const imp of stylesResult.extraImports) {
-      await insertImportLine(globalsPath, imp);
-    }
-    await insertImportLine(globalsPath, '@import "./ui/index.css";');
-    console.log(
-      `  ${CHECK}  Added @import to ${path4.relative(cwd, globalsPath)}`
-    );
-  } else {
-    await fsp.mkdir(path4.dirname(globalsPath), { recursive: true });
-    const scaffold = [
-      '@import "tailwindcss";',
-      ...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 (stylesResult.dependencies.length > 0) {
-    const deps = [...new Set(stylesResult.dependencies)].sort();
-    console.log("");
-    await installDependencies(deps, cwd);
-  }
-  console.log("");
-  console.log("  Next steps:");
-  console.log("    stera-ui add <component>");
-  if (strategy === "skip") {
-    console.log("");
-    console.log(
-      `  ${dim("Font setup was skipped. See https://ui.stera.sh for font configuration docs.")}`
-    );
-  }
-  console.log("");
-}
-export {
-  init
-};