@salty-css/core 0.1.0-alpha.5 → 0.1.0-alpha.7

package/bin/main.js

@@ -1,14 +1,43 @@
 import { Command } from "commander";
 import { existsSync, watch } from "fs";
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { join, relative, parse, format } from "path";
-import ejs from "ejs";
-import { p as pascalCase } from "../pascal-case-F3Usi5Wf.js";
 import { l as logger, a as logError, SaltyCompiler } from "../compiler/salty-compiler.js";
+import { isSaltyFile } from "../compiler/helpers.js";
+import { c as checkShouldRestart } from "../should-restart-CXIO0jxY.js";
+import { join, relative, parse, format } from "path";
+import { readFile, writeFile, mkdir } from "fs/promises";
 import { exec } from "child_process";
 import ora from "ora";
-import { c as checkShouldRestart } from "../should-restart-CXIO0jxY.js";
-import { isSaltyFile } from "../compiler/helpers.js";
+import { p as pascalCase } from "../pascal-case-F3Usi5Wf.js";
+import ejs from "ejs";
+const defaultPackageJsonPath = join(process.cwd(), "package.json");
+const readPackageJson = async (filePath = defaultPackageJsonPath) => {
+  const content = await readFile(filePath, "utf-8").then(JSON.parse).catch(() => void 0);
+  if (!content) throw "Could not read package.json file!";
+  return content;
+};
+const updatePackageJson = async (content, filePath = defaultPackageJsonPath) => {
+  if (typeof content === "object") content = JSON.stringify(content, null, 2);
+  await writeFile(filePath, content);
+};
+const readThisPackageJson = async () => {
+  const packageJsonPath = new URL("../package.json", import.meta.url);
+  return readPackageJson(packageJsonPath);
+};
+const corePackages = {
+  core: (version) => `@salty-css/core@${version}`,
+  eslintConfigCore: (version) => `@salty-css/eslint-config-core@${version}`
+};
+const addPrepareScript = (pkg) => {
+  if (!pkg.scripts) pkg.scripts = {};
+  const current = pkg.scripts["prepare"];
+  if (current) {
+    if (current.includes("salty-css")) return { changed: false, pkg };
+    pkg.scripts["prepare"] = current + " && npx salty-css build";
+  } else {
+    pkg.scripts["prepare"] = "npx salty-css build";
+  }
+  return { changed: true, pkg };
+};
 const execAsync = (command) => {
   return new Promise((resolve, reject) => {
     exec(command, (error) => {
@@ -37,365 +66,542 @@ async function formatWithPrettier(filePath) {
     logger.error(`Error formatting ${filePath} with Prettier:`, error);
   }
 }
-async function main() {
-  const program = new Command();
-  program.name("salty-css").description("Salty-CSS CLI tool to help with annoying configuration tasks.");
-  const files = {
-    // Core files
-    "salty.config.ts": import("../salty.config-DjosWdPw.js"),
-    "saltygen/index.css": import("../index-DKz1QXqs.js"),
-    // React
-    "react/react-styled-file.ts": import("../react-styled-file-B99mwk0w.js"),
-    "react/react-vanilla-file.ts": import("../react-vanilla-file-D9px70iK.js")
-  };
-  const readTemplate = async (fileName, options) => {
-    const { default: file } = await files[fileName];
-    const content = ejs.render(file, options);
-    return { fileName, content };
-  };
-  const readRCFile = async () => {
-    const rcPath = join(process.cwd(), ".saltyrc.json");
-    const rcContent = await readFile(rcPath, "utf-8").then(JSON.parse).catch(() => ({}));
-    return rcContent;
-  };
-  const defaultPackageJsonPath = join(process.cwd(), "package.json");
-  const readPackageJson = async (filePath = defaultPackageJsonPath) => {
-    const packageJsonContent = await readFile(filePath, "utf-8").then(JSON.parse).catch(() => void 0);
-    if (!packageJsonContent) throw "Could not read package.json file!";
-    return packageJsonContent;
-  };
-  const updatePackageJson = async (content, filePath = defaultPackageJsonPath) => {
-    if (typeof content === "object") content = JSON.stringify(content, null, 2);
-    await writeFile(filePath, content);
-  };
-  const readThisPackageJson = async () => {
-    const packageJsonPath = new URL("../package.json", import.meta.url);
-    return readPackageJson(packageJsonPath);
-  };
-  const getDefaultProject = async () => {
-    const rcContent = await readRCFile();
-    return rcContent.defaultProject;
-  };
-  const defaultProject = await getDefaultProject();
-  const currentPackageJson = await readThisPackageJson();
-  const packages = {
-    core: `@salty-css/core@${currentPackageJson.version}`,
-    react: `@salty-css/react@${currentPackageJson.version}`,
-    eslintConfigCore: `@salty-css/eslint-config-core@${currentPackageJson.version}`,
-    vite: `@salty-css/vite@${currentPackageJson.version}`,
-    next: `@salty-css/next@${currentPackageJson.version}`
-  };
-  const resolveProjectDir = (dir) => {
-    const dirName = dir === "." ? "" : dir;
-    const rootDir = process.cwd();
-    const projectDir = join(rootDir, dirName);
-    return projectDir;
-  };
-  program.command("init [directory]").description("Initialize a new Salty-CSS project.").option("-d, --dir <dir>", "Project directory to initialize the project in.").option("--css-file <css-file>", "Existing CSS file where to import the generated CSS. Path must be relative to the given project directory.").option("--skip-install", "Skip installing dependencies.").action(async function(_dir = ".") {
-    const packageJson = await readPackageJson().catch(() => void 0);
-    if (!packageJson) return logError("Salty CSS project must be initialized in a directory with a package.json file.");
-    logger.info("Initializing a new Salty-CSS project!");
-    const { dir = _dir, cssFile, skipInstall } = this.opts();
-    if (!dir) return logError("Project directory must be provided. Add it as the first argument after init command or use the --dir option.");
-    if (!skipInstall) await npmInstall(packages.core, packages.react);
-    const rootDir = process.cwd();
-    const projectDir = resolveProjectDir(dir);
-    const projectFiles = await Promise.all([readTemplate("salty.config.ts"), readTemplate("saltygen/index.css")]);
-    const saltyCompiler = new SaltyCompiler(projectDir);
-    await mkdir(projectDir, { recursive: true });
-    const writeFiles = projectFiles.map(async ({ fileName, content }) => {
-      const filePath = join(projectDir, fileName);
-      const existingContent = await readFile(filePath, "utf-8").catch(() => void 0);
-      if (existingContent !== void 0) {
-        logger.debug("File already exists: " + filePath);
-        return;
-      }
-      const additionalFolders = fileName.split("/").slice(0, -1).join("/");
-      if (additionalFolders) await mkdir(join(projectDir, additionalFolders), { recursive: true });
-      logger.info("Creating file: " + filePath);
-      await writeFile(filePath, content);
-      await formatWithPrettier(filePath);
-    });
-    await Promise.all(writeFiles);
-    const relativeProjectPath = relative(rootDir, projectDir) || ".";
-    const saltyrcPath = join(rootDir, ".saltyrc.json");
-    const existingSaltyrc = await readFile(saltyrcPath, "utf-8").catch(() => void 0);
-    if (existingSaltyrc === void 0) {
-      logger.info("Creating file: " + saltyrcPath);
-      const rcContent = {
-        $schema: "./node_modules/@salty-css/core/.saltyrc.schema.json",
-        info: "This file is used to define projects and their configurations for Salty CSS cli. Do not delete, modify or add this file to .gitignore.",
-        defaultProject: relativeProjectPath,
-        projects: [
-          {
-            dir: relativeProjectPath,
-            framework: "react"
-          }
-        ]
-      };
-      const content = JSON.stringify(rcContent, null, 2);
-      await writeFile(saltyrcPath, content);
-      await formatWithPrettier(saltyrcPath);
-    } else {
-      const rcContent = JSON.parse(existingSaltyrc);
-      const projects = (rcContent == null ? void 0 : rcContent.projects) || [];
-      const projectIndex = projects.findIndex((p) => p.dir === relativeProjectPath);
-      if (projectIndex === -1) {
-        projects.push({ dir: relativeProjectPath, framework: "react" });
-        rcContent.projects = [...projects];
-        const content = JSON.stringify(rcContent, null, 2);
-        if (content !== existingSaltyrc) {
-          logger.info("Edit file: " + saltyrcPath);
-          await writeFile(saltyrcPath, content);
-          await formatWithPrettier(saltyrcPath);
-        }
-      }
-    }
-    const gitIgnorePath = join(rootDir, ".gitignore");
-    const gitIgnoreContent = await readFile(gitIgnorePath, "utf-8").catch(() => void 0);
-    if (gitIgnoreContent !== void 0) {
-      const alreadyIgnoresSaltygen = gitIgnoreContent.includes("saltygen");
-      if (!alreadyIgnoresSaltygen) {
-        logger.info("Edit file: " + gitIgnorePath);
-        await writeFile(gitIgnorePath, gitIgnoreContent + "\n\n# Salty-CSS\nsaltygen\n");
-      }
-    }
-    const cssFileFoldersToLookFor = ["src", "public", "assets", "styles", "css", "app"];
-    const secondLevelFolders = ["styles", "css", "app", "pages"];
-    const cssFilesToLookFor = ["index", "styles", "main", "app", "global", "globals"];
-    const cssFileExtensions = [".css", ".scss", ".sass"];
-    const getTargetCssFile = async () => {
-      if (cssFile) return cssFile;
-      for (const folder of cssFileFoldersToLookFor) {
-        for (const file of cssFilesToLookFor) {
-          for (const ext of cssFileExtensions) {
-            const filePath = join(projectDir, folder, file + ext);
-            const fileContent = await readFile(filePath, "utf-8").catch(() => void 0);
-            if (fileContent !== void 0) return relative(projectDir, filePath);
-            for (const secondLevelFolder of secondLevelFolders) {
-              const filePath2 = join(projectDir, folder, secondLevelFolder, file + ext);
-              const fileContent2 = await readFile(filePath2, "utf-8").catch(() => void 0);
-              if (fileContent2 !== void 0) return relative(projectDir, filePath2);
-            }
-          }
-        }
-      }
-      return void 0;
-    };
-    const targetCSSFile = await getTargetCssFile();
-    if (targetCSSFile) {
-      const cssFilePath = join(projectDir, targetCSSFile);
-      const cssFileContent = await readFile(cssFilePath, "utf-8").catch(() => void 0);
-      if (cssFileContent !== void 0) {
-        const alreadyImportsSaltygen = cssFileContent.includes("saltygen");
-        if (!alreadyImportsSaltygen) {
-          const cssFileFolder = join(cssFilePath, "..");
-          const relativePath = relative(cssFileFolder, join(projectDir, "saltygen/index.css"));
-          const importStatement = `@import '${relativePath}';`;
-          logger.info("Adding global import statement to CSS file: " + cssFilePath);
-          await writeFile(cssFilePath, importStatement + "\n" + cssFileContent);
-          await formatWithPrettier(cssFilePath);
-        }
-      }
-    } else {
-      logger.warn("Could not find a CSS file to import the generated CSS. Please add it manually.");
-    }
-    const eslintConfigs = {
-      projectJs: join(projectDir, "eslint.config.js"),
-      rootJs: join(rootDir, "eslint.config.js"),
-      projectMjs: join(projectDir, "eslint.config.mjs"),
-      rootMjs: join(rootDir, "eslint.config.mjs"),
-      projectJson: join(projectDir, ".eslintrc.json"),
-      rootJson: join(rootDir, ".eslintrc.json")
+const SALTYRC_FILENAME = ".saltyrc.json";
+const SALTYRC_SCHEMA = "./node_modules/@salty-css/core/.saltyrc.schema.json";
+const SALTYRC_INFO = "This file is used to define projects and their configurations for Salty CSS cli. Do not delete, modify or add this file to .gitignore.";
+const saltyrcPath = (rootDir = process.cwd()) => join(rootDir, SALTYRC_FILENAME);
+const readRc = async (rootDir = process.cwd()) => {
+  const content = await readFile(saltyrcPath(rootDir), "utf-8").then(JSON.parse).catch(() => ({}));
+  return content;
+};
+const readRawRc = async (rootDir = process.cwd()) => {
+  return readFile(saltyrcPath(rootDir), "utf-8").catch(() => void 0);
+};
+const getDefaultProject = async (rootDir = process.cwd()) => {
+  const rc = await readRc(rootDir);
+  return rc.defaultProject;
+};
+const upsertProjectInRc = (existingRaw, relativeProjectPath, framework) => {
+  const projectPath = join(relativeProjectPath, framework.srcDirectory);
+  if (existingRaw === void 0) {
+    const fresh = {
+      $schema: SALTYRC_SCHEMA,
+      info: SALTYRC_INFO,
+      defaultProject: projectPath,
+      projects: [{ dir: projectPath, framework: framework.name }]
     };
-    const eslintConfigToUse = Object.values(eslintConfigs).find((path) => existsSync(path));
-    if (eslintConfigToUse) {
-      if (!skipInstall) await npmInstall(packages.eslintConfigCore);
-      const eslintConfigContent = await readFile(eslintConfigToUse, "utf-8").catch(() => void 0);
-      if (!eslintConfigContent) return logError("Could not read ESLint config file.");
-      const alreadyHasSaltyConfig = eslintConfigContent.includes("salty-css");
-      if (!alreadyHasSaltyConfig) {
-        logger.info("Edit file: " + eslintConfigToUse);
-        if (eslintConfigToUse.endsWith("js")) {
-          const importStatement = 'import saltyCss from "@salty-css/eslint-config-core/flat";';
-          let newContent = `${importStatement}
-${eslintConfigContent}`;
-          const isTsEslint = eslintConfigContent.includes("typescript-eslint");
-          if (isTsEslint) {
-            if (newContent.includes(".config(")) newContent = newContent.replace(".config(", ".config(saltyCss,");
-            else logger.warn("Could not find the correct place to add the Salty-CSS config for ESLint. Please add it manually.");
-          } else {
-            if (newContent.includes("export default [")) newContent = newContent.replace("export default [", "export default [ saltyCss,");
-            else if (newContent.includes("eslintConfig = [")) newContent = newContent.replace("eslintConfig = [", "eslintConfig = [ saltyCss,");
-            else logger.warn("Could not find the correct place to add the Salty-CSS config for ESLint. Please add it manually.");
-          }
-          await writeFile(eslintConfigToUse, newContent);
-          await formatWithPrettier(eslintConfigToUse);
-        } else {
-          const eslintConfigJson = JSON.parse(eslintConfigContent);
-          if (!eslintConfigJson.extends) eslintConfigJson.extends = [];
-          eslintConfigJson.extends.push("@salty-css/core");
-          const modifiedEslintConfigContent = JSON.stringify(eslintConfigJson, null, 2);
-          await writeFile(eslintConfigToUse, modifiedEslintConfigContent);
-          await formatWithPrettier(eslintConfigToUse);
-        }
-      }
-    }
-    const viteConfigPath = join(projectDir, "vite.config.ts");
-    const viteConfigContent = await readFile(viteConfigPath, "utf-8").catch(() => void 0);
-    if (viteConfigContent !== void 0) {
-      const alreadyHasPlugin = viteConfigContent.includes("saltyPlugin");
-      if (!alreadyHasPlugin) {
-        logger.info("Edit file: " + viteConfigPath);
-        const pluginImport = "import { saltyPlugin } from '@salty-css/vite';\n";
-        const pluginConfig = "saltyPlugin(__dirname),";
-        const newContent = viteConfigContent.replace(/(plugins: \[)/, `$1
-  ${pluginConfig}`);
-        if (!skipInstall) await npmInstall(`-D ${packages.vite}`);
-        logger.info("Adding Salty-CSS plugin to Vite config...");
-        await writeFile(viteConfigPath, pluginImport + newContent);
-        await formatWithPrettier(viteConfigPath);
-      }
-    }
-    const nextConfigFiles = ["next.config.js", "next.config.cjs", "next.config.ts", "next.config.mjs"];
-    const nextConfigPath = nextConfigFiles.map((file) => join(projectDir, file)).find((path) => existsSync(path));
-    if (nextConfigPath) {
-      let nextConfigContent = await readFile(nextConfigPath, "utf-8").catch(() => void 0);
-      if (nextConfigContent !== void 0) {
-        const alreadyHasPlugin = nextConfigContent.includes("withSaltyCss");
-        if (!alreadyHasPlugin) {
-          let saltyCssAppended = false;
-          const hasPluginsArray = /\splugins([^=]*)=[^[]\[/.test(nextConfigContent);
-          if (hasPluginsArray && !saltyCssAppended) {
-            nextConfigContent = nextConfigContent.replace(/\splugins([^=]*)=[^[]\[/, (_, config) => {
-              return ` plugins${config}= [withSaltyCss,`;
-            });
-            saltyCssAppended = true;
-          }
-          const useRequire = nextConfigContent.includes("module.exports");
-          const pluginImport = useRequire ? "const { withSaltyCss } = require('@salty-css/next');\n" : "import { withSaltyCss } from '@salty-css/next';\n";
-          if (useRequire && !saltyCssAppended) {
-            nextConfigContent = nextConfigContent.replace(/module.exports = ([^;]+)/, (_, config) => {
-              return `module.exports = withSaltyCss(${config})`;
-            });
-            saltyCssAppended = true;
-          } else if (!saltyCssAppended) {
-            nextConfigContent = nextConfigContent.replace(/export default ([^;]+)/, (_, config) => {
-              return `export default withSaltyCss(${config})`;
-            });
-          }
-          if (!skipInstall) await npmInstall(`-D ${packages.next}`);
-          logger.info("Adding Salty-CSS plugin to Next.js config...");
-          await writeFile(nextConfigPath, pluginImport + nextConfigContent);
-          await formatWithPrettier(nextConfigPath);
-        }
-      }
-    }
-    const packageJsonContent = await readPackageJson().catch(() => logError("Could not read package.json file.")).then((content) => {
-      if (!content.scripts) content.scripts = {};
-      if (content.scripts.prepare) {
-        const alreadyHasSaltyCss = content.scripts.prepare.includes("salty-css");
-        if (!alreadyHasSaltyCss) {
-          logger.info("Edit file: " + defaultPackageJsonPath);
-          content.scripts.prepare = content.scripts.prepare + " && npx salty-css build";
-        }
-      } else {
-        logger.info("Edit file: " + defaultPackageJsonPath);
-        content.scripts.prepare = "npx salty-css build";
-      }
-      return content;
-    });
-    await updatePackageJson(packageJsonContent);
-    logger.info("Running the build to generate initial CSS...");
-    await saltyCompiler.generateCss();
-    logger.info("🎉 Salty CSS project initialized successfully!");
-    logger.info("Next steps:");
-    logger.info("1. Configure variables and templates in `salty.config.ts`");
-    logger.info("2. Create a new component with `npx salty-css generate [component-name]`");
-    logger.info("3. Run `npx salty-css build` to generate the CSS");
-    logger.info("4. Read about the features in the documentation: https://salty-css.dev");
-    logger.info("5. Star the project on GitHub: https://github.com/margarita-form/salty-css ⭐");
-  });
+    return { content: JSON.stringify(fresh, null, 2), changed: true, created: true };
+  }
+  const rc = JSON.parse(existingRaw);
+  const projects = rc.projects || [];
+  const exists = projects.some((p) => p.dir === projectPath);
+  if (exists) return { content: existingRaw, changed: false, created: false };
+  projects.push({ dir: projectPath, framework: framework.name });
+  rc.projects = [...projects];
+  const next = JSON.stringify(rc, null, 2);
+  return { content: next, changed: next !== existingRaw, created: false };
+};
+const writeProjectToRc = async (cwd, relativeProjectPath, framework) => {
+  const path = saltyrcPath(cwd);
+  const existing = await readRawRc(cwd);
+  const { content, changed, created } = upsertProjectInRc(existing, relativeProjectPath, framework);
+  if (!changed) return false;
+  if (created) logger.info("Creating file: " + path);
+  else logger.info("Edit file: " + path);
+  await writeFile(path, content);
+  await formatWithPrettier(path);
+  return true;
+};
+const getProjectFramework = (rc, relativeProjectPath) => {
+  const projects = rc.projects || [];
+  const entry = projects.find((p) => p.dir === relativeProjectPath);
+  return entry == null ? void 0 : entry.framework;
+};
+const resolveProjectDir = (dir, rootDir = process.cwd()) => {
+  const dirName = dir === "." ? "" : dir;
+  return join(rootDir, dirName);
+};
+const buildContext = async (opts) => {
+  const cwd = process.cwd();
+  const projectDir = resolveProjectDir(opts.dir, cwd);
+  const relativeProjectPath = relative(cwd, projectDir) || ".";
+  const packageJson = await readPackageJson().catch(() => void 0);
+  if (opts.requirePackageJson !== false && !packageJson) {
+    throw new Error("Salty CSS project must be initialized in a directory with a package.json file.");
+  }
+  const rcFile = await readRc(cwd);
+  const cliPackageJson = await readThisPackageJson();
+  return {
+    cwd,
+    projectDir,
+    relativeProjectPath,
+    packageJson,
+    rcFile,
+    cliVersion: cliPackageJson.version || "0.0.0",
+    skipInstall: !!opts.skipInstall
+  };
+};
+const registerBuildCommand = (program, defaultProject) => {
   program.command("build [directory]").alias("b").description("Build the Salty-CSS project.").option("-d, --dir <dir>", "Project directory to build the project in.").option("--watch", "Watch for changes and rebuild the project.").action(async function(_dir = defaultProject) {
     logger.info("Building the Salty-CSS project...");
     const { dir = _dir, watch: watch$1 } = this.opts();
-    if (!dir) return logError("Project directory must be provided. Add it as the first argument after build command or use the --dir option.");
-    const projectDir = resolveProjectDir(dir);
-    const saltyCompiler = new SaltyCompiler(projectDir);
-    await saltyCompiler.generateCss();
+    const resolved = dir ?? await getDefaultProject();
+    if (!resolved) return logError("Project directory must be provided. Add it as the first argument after build command or use the --dir option.");
+    const projectDir = resolveProjectDir(resolved);
+    const compiler = new SaltyCompiler(projectDir);
+    await compiler.generateCss();
     if (watch$1) {
       logger.info("Watching for changes in the project directory...");
-      watch(projectDir, { recursive: true }, async (event, filePath) => {
+      watch(projectDir, { recursive: true }, async (_event, filePath) => {
         const shouldRestart = await checkShouldRestart(filePath);
         if (shouldRestart) {
-          await saltyCompiler.generateCss(false);
-        } else {
-          const saltyFile = isSaltyFile(filePath);
-          if (saltyFile) await saltyCompiler.generateFile(filePath);
+          await compiler.generateCss(false);
+        } else if (isSaltyFile(filePath)) {
+          await compiler.generateFile(filePath);
         }
       });
     }
   });
-  program.command("generate [file] [directory]").alias("g").description("Generate a new component file.").option("-f, --file <file>", "File to generate.").option("-d, --dir <dir>", "Project directory to generate the file in.").option("-t, --tag <tag>", "HTML tag of the component.", "div").option("-n, --name <name>", "Name of the component.").option("-c, --className <className>", "CSS class of the component.").option("-r, --reactComponent", "Generate a React component as well.").action(async function(_file, _dir = defaultProject) {
+};
+const astroConfigFiles = ["astro.config.mjs", "astro.config.ts", "astro.config.js", "astro.config.cjs"];
+const findAstroConfig = (projectDir) => {
+  for (const name of astroConfigFiles) {
+    const path = join(projectDir, name);
+    if (existsSync(path)) return path;
+  }
+  return null;
+};
+const hasAstroDependency = (ctx) => {
+  const pkg = ctx.packageJson;
+  if (!pkg) return false;
+  const all = { ...pkg.dependencies, ...pkg.devDependencies };
+  return Object.prototype.hasOwnProperty.call(all, "astro");
+};
+const astroFramework = {
+  name: "astro",
+  srcDirectory: "src",
+  detect: (ctx) => Boolean(findAstroConfig(ctx.projectDir)) || hasAstroDependency(ctx),
+  runtimePackage: (version) => `@salty-css/astro@${version}`,
+  templates: {
+    styled: "astro/styled-file.ts",
+    component: {
+      styled: "astro/styled-file.ts",
+      wrapper: "astro/component.astro",
+      wrapperExt: ".astro"
+    }
+  }
+};
+const reactFramework = {
+  name: "react",
+  srcDirectory: "",
+  detect: () => true,
+  // default fallback — evaluated last in the registry
+  runtimePackage: (version) => `@salty-css/react@${version}`,
+  templates: {
+    styled: "react/styled-file.ts",
+    component: {
+      styled: "react/styled-file.ts",
+      wrapper: "react/vanilla-file.ts",
+      wrapperExt: ".tsx"
+    }
+  }
+};
+const frameworkRegistry = [astroFramework, reactFramework];
+const frameworksByName = {
+  astro: astroFramework,
+  react: reactFramework
+};
+const detectFramework = async (ctx) => {
+  for (const adapter of frameworkRegistry) {
+    if (await adapter.detect(ctx)) return adapter;
+  }
+  return reactFramework;
+};
+const getFramework = (name) => {
+  if (!name) return void 0;
+  return frameworksByName[name];
+};
+const templateLoaders = {
+  "salty.config.ts": () => import("../salty.config-DjosWdPw.js"),
+  "saltygen/index.css": () => import("../index-DKz1QXqs.js"),
+  "react/styled-file.ts": () => import("../styled-file-Cda3EeR6.js"),
+  "react/vanilla-file.ts": () => import("../vanilla-file-1kOqbCIM.js"),
+  "astro/styled-file.ts": () => import("../styled-file-DLcgYmGN.js"),
+  "astro/component.astro": () => import("../astro-component-5hrNTCJ5.js")
+};
+const readTemplate = async (key, options) => {
+  const { default: file } = await templateLoaders[key]();
+  const content = ejs.render(file, options);
+  return { fileName: key, content };
+};
+const registerGenerateCommand = (program, defaultProject) => {
+  program.command("generate [file] [directory]").alias("g").description("Generate a new component file.").option("-f, --file <file>", "File to generate.").option("-d, --dir <dir>", "Project directory to generate the file in.").option("-t, --tag <tag>", "HTML tag of the component.", "div").option("-n, --name <name>", "Name of the component.").option("-c, --className <className>", "CSS class of the component.").option("-r, --reactComponent", "Generate a wrapper component file alongside the styled definition.").action(async function(_file, _dir = defaultProject) {
     const { file = _file, dir = _dir, tag, name, className, reactComponent = false } = this.opts();
     if (!file) return logError("File to generate must be provided. Add it as the first argument after generate command or use the --file option.");
     if (!dir) return logError("Project directory must be provided. Add it as the second argument after generate command or use the --dir option.");
-    const projectDir = resolveProjectDir(dir);
+    let ctx;
+    try {
+      ctx = await buildContext({ dir, requirePackageJson: false });
+    } catch (err) {
+      return logError(err instanceof Error ? err.message : String(err));
+    }
+    const rcFramework = getFramework(getProjectFramework(ctx.rcFile, ctx.relativeProjectPath));
+    const framework = rcFramework ?? await detectFramework(ctx);
     const additionalFolders = file.split("/").slice(0, -1).join("/");
-    if (additionalFolders) await mkdir(join(projectDir, additionalFolders), { recursive: true });
-    const filePath = join(projectDir, file);
+    if (additionalFolders) await mkdir(join(ctx.projectDir, additionalFolders), { recursive: true });
+    const filePath = join(ctx.projectDir, file);
     const parsedFilePath = parse(filePath);
-    if (!parsedFilePath.ext) {
-      parsedFilePath.ext = ".ts";
-    }
-    if (!parsedFilePath.name.endsWith(".css")) {
-      parsedFilePath.name = parsedFilePath.name + ".css";
-    }
+    if (!parsedFilePath.ext) parsedFilePath.ext = ".ts";
+    if (!parsedFilePath.name.endsWith(".css")) parsedFilePath.name = parsedFilePath.name + ".css";
     parsedFilePath.base = parsedFilePath.name + parsedFilePath.ext;
     const formattedStyledFilePath = format(parsedFilePath);
     const alreadyExists = await readFile(formattedStyledFilePath, "utf-8").catch(() => void 0);
     if (alreadyExists !== void 0) {
-      logger.error("File already exists:", formattedStyledFilePath);
+      logger.error("File already exists: " + formattedStyledFilePath);
       return;
     }
     let styledComponentName = pascalCase(name || parsedFilePath.base.replace(/\.css\.\w+$/, ""));
     if (reactComponent) {
+      if (!framework.templates.component) {
+        return logError(`--reactComponent is not supported for the ${framework.name} framework.`);
+      }
       const componentName = styledComponentName + "Component";
       styledComponentName = styledComponentName + "Wrapper";
       const fileName = parsedFilePath.base.replace(/\.css\.\w+$/, "");
-      const { content: reactContent } = await readTemplate("react/react-vanilla-file.ts", { tag, componentName, styledComponentName, className, fileName });
+      const { content: wrapperContent } = await readTemplate(framework.templates.component.wrapper, {
+        tag,
+        componentName,
+        styledComponentName,
+        className,
+        fileName
+      });
       parsedFilePath.name = fileName.replace(/\.css$/, "");
-      parsedFilePath.ext = ".tsx";
+      parsedFilePath.ext = framework.templates.component.wrapperExt;
       parsedFilePath.base = parsedFilePath.name + parsedFilePath.ext;
-      const formattedReactFilePath = format(parsedFilePath);
-      logger.info("Generating a new file: " + formattedReactFilePath);
-      await writeFile(formattedReactFilePath, reactContent);
-      await formatWithPrettier(formattedReactFilePath);
+      const formattedWrapperPath = format(parsedFilePath);
+      logger.info("Generating a new file: " + formattedWrapperPath);
+      await writeFile(formattedWrapperPath, wrapperContent);
+      await formatWithPrettier(formattedWrapperPath);
     }
-    const { content } = await readTemplate("react/react-styled-file.ts", { tag, name: styledComponentName, className });
+    const styledKey = reactComponent && framework.templates.component ? framework.templates.component.styled : framework.templates.styled;
+    const { content } = await readTemplate(styledKey, { tag, name: styledComponentName, className });
     logger.info("Generating a new file: " + formattedStyledFilePath);
     await writeFile(formattedStyledFilePath, content);
     await formatWithPrettier(formattedStyledFilePath);
   });
-  const getSaltyCssPackages = async () => {
-    const packageJSONPath = join(process.cwd(), "package.json");
-    const packageJson = await readPackageJson(packageJSONPath).catch((err) => logError(err));
-    if (!packageJson) return logError("Could not read package.json file.");
-    const allDependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
-    const saltyCssPackages = Object.entries(allDependencies).filter(([name]) => name === "salty-css" || name.startsWith("@salty-css/"));
-    if (!saltyCssPackages.length) {
-      return logError(
-        "No Salty-CSS packages found in package.json. Make sure you are running update command in the same directory! Used package.json path: " + packageJSONPath
-      );
+};
+const CSS_FILE_FOLDERS = ["src", "public", "assets", "styles", "css", "app"];
+const CSS_SECOND_LEVEL_FOLDERS = ["styles", "css", "app", "pages"];
+const CSS_FILE_NAMES = ["index", "styles", "main", "app", "global", "globals"];
+const CSS_FILE_EXTENSIONS = [".css", ".scss", ".sass"];
+const findGlobalCssFile = async (projectDir) => {
+  for (const folder of CSS_FILE_FOLDERS) {
+    for (const file of CSS_FILE_NAMES) {
+      for (const ext of CSS_FILE_EXTENSIONS) {
+        const filePath = join(projectDir, folder, file + ext);
+        const fileContent = await readFile(filePath, "utf-8").catch(() => void 0);
+        if (fileContent !== void 0) return relative(projectDir, filePath);
+        for (const second of CSS_SECOND_LEVEL_FOLDERS) {
+          const nestedPath = join(projectDir, folder, second, file + ext);
+          const nestedContent = await readFile(nestedPath, "utf-8").catch(() => void 0);
+          if (nestedContent !== void 0) return relative(projectDir, nestedPath);
+        }
+      }
     }
-    return saltyCssPackages;
-  };
+  }
+  return void 0;
+};
+const astroPackage = (version) => `@salty-css/astro@${version}`;
+const SALTY_ASTRO_IMPORT = "import saltyIntegration from '@salty-css/astro/integration';\n";
+const editAstroConfig = (existing) => {
+  if (existing.includes("@salty-css/astro")) return { content: null };
+  let next = existing;
+  let inserted = false;
+  if (/integrations\s*:\s*\[/.test(next)) {
+    next = next.replace(/integrations\s*:\s*\[/, (m) => `${m}saltyIntegration(),`);
+    inserted = true;
+  } else if (/defineConfig\s*\(\s*\{/.test(next)) {
+    next = next.replace(/defineConfig\s*\(\s*\{/, (m) => `${m}
+  integrations: [saltyIntegration()],`);
+    inserted = true;
+  }
+  if (!inserted) {
+    return {
+      content: null,
+      warning: "Could not find a place to add saltyIntegration() in the Astro config. Please add it manually."
+    };
+  }
+  return { content: SALTY_ASTRO_IMPORT + next };
+};
+const astroIntegration = {
+  name: "astro",
+  detect: (ctx) => findAstroConfig(ctx.projectDir),
+  apply: async (ctx, configPath) => {
+    const existing = await readFile(configPath, "utf-8").catch(() => void 0);
+    if (existing === void 0) return { changed: false };
+    const result = editAstroConfig(existing);
+    if (result.warning) logger.warn(result.warning);
+    if (result.content === null) return { changed: false };
+    if (!ctx.skipInstall) await npmInstall(`-D ${astroPackage(ctx.cliVersion)}`);
+    logger.info("Adding Salty-CSS integration to Astro config: " + configPath);
+    await writeFile(configPath, result.content);
+    await formatWithPrettier(configPath);
+    return { changed: true };
+  }
+};
+const ESLINT_CONFIG_CANDIDATES = [
+  // Project-local candidates first, then root-level.
+  ["projectJs", "eslint.config.js"],
+  ["rootJs", "eslint.config.js"],
+  ["projectMjs", "eslint.config.mjs"],
+  ["rootMjs", "eslint.config.mjs"],
+  ["projectJson", ".eslintrc.json"],
+  ["rootJson", ".eslintrc.json"]
+];
+const eslintConfigCandidates = (projectDir, rootDir) => {
+  return ESLINT_CONFIG_CANDIDATES.map(([scope, name]) => {
+    const base = scope.startsWith("root") ? rootDir : projectDir;
+    return join(base, name);
+  });
+};
+const editEslintConfig = (existing, isJsFlat) => {
+  if (existing.includes("salty-css")) return { content: null };
+  if (isJsFlat) {
+    const importStatement = 'import saltyCss from "@salty-css/eslint-config-core/flat";';
+    let newContent = `${importStatement}
+${existing}`;
+    const isTsEslint = existing.includes("typescript-eslint");
+    if (isTsEslint) {
+      if (newContent.includes(".config(")) {
+        newContent = newContent.replace(".config(", ".config(saltyCss,");
+      } else {
+        return {
+          content: null,
+          warning: "Could not find the correct place to add the Salty-CSS config for ESLint. Please add it manually."
+        };
+      }
+    } else {
+      if (newContent.includes("export default [")) {
+        newContent = newContent.replace("export default [", "export default [ saltyCss,");
+      } else if (newContent.includes("eslintConfig = [")) {
+        newContent = newContent.replace("eslintConfig = [", "eslintConfig = [ saltyCss,");
+      } else {
+        return {
+          content: null,
+          warning: "Could not find the correct place to add the Salty-CSS config for ESLint. Please add it manually."
+        };
+      }
+    }
+    return { content: newContent };
+  }
+  const json = JSON.parse(existing);
+  if (!json.extends) json.extends = [];
+  if (!json.extends.includes("@salty-css/core")) json.extends.push("@salty-css/core");
+  return { content: JSON.stringify(json, null, 2) };
+};
+const eslintIntegration = {
+  name: "eslint",
+  detect: (ctx) => {
+    const candidates = eslintConfigCandidates(ctx.projectDir, ctx.cwd);
+    return candidates.find((p) => existsSync(p)) ?? null;
+  },
+  apply: async (ctx, configPath) => {
+    const existing = await readFile(configPath, "utf-8").catch(() => void 0);
+    if (existing === void 0) {
+      logger.error("Could not read ESLint config file.");
+      return { changed: false };
+    }
+    if (!ctx.skipInstall) await npmInstall(corePackages.eslintConfigCore(ctx.cliVersion));
+    const result = editEslintConfig(existing, configPath.endsWith("js"));
+    if (result.warning) logger.warn(result.warning);
+    if (result.content === null) return { changed: false };
+    logger.info("Edit file: " + configPath);
+    await writeFile(configPath, result.content);
+    await formatWithPrettier(configPath);
+    return { changed: true };
+  }
+};
+const nextConfigFiles = ["next.config.js", "next.config.cjs", "next.config.ts", "next.config.mjs"];
+const nextPackage = (version) => `@salty-css/next@${version}`;
+const editNextConfig = (existing) => {
+  if (existing.includes("withSaltyCss")) return { content: null };
+  let next = existing;
+  let saltyCssAppended = false;
+  const hasPluginsArray = /\splugins([^=]*)=[^[]\[/.test(next);
+  if (hasPluginsArray) {
+    next = next.replace(/\splugins([^=]*)=[^[]\[/, (_, config) => ` plugins${config}= [withSaltyCss,`);
+    saltyCssAppended = true;
+  }
+  const useRequire = next.includes("module.exports");
+  const pluginImport = useRequire ? "const { withSaltyCss } = require('@salty-css/next');\n" : "import { withSaltyCss } from '@salty-css/next';\n";
+  if (useRequire && !saltyCssAppended) {
+    next = next.replace(/module.exports = ([^;]+)/, (_, config) => `module.exports = withSaltyCss(${config})`);
+    saltyCssAppended = true;
+  } else if (!saltyCssAppended) {
+    next = next.replace(/export default ([^;]+)/, (_, config) => `export default withSaltyCss(${config})`);
+  }
+  return { content: pluginImport + next };
+};
+const nextIntegration = {
+  name: "next",
+  detect: (ctx) => {
+    const found = nextConfigFiles.map((file) => join(ctx.projectDir, file)).find((p) => existsSync(p));
+    return found ?? null;
+  },
+  apply: async (ctx, configPath) => {
+    const existing = await readFile(configPath, "utf-8").catch(() => void 0);
+    if (existing === void 0) return { changed: false };
+    const { content } = editNextConfig(existing);
+    if (content === null) return { changed: false };
+    if (!ctx.skipInstall) await npmInstall(`-D ${nextPackage(ctx.cliVersion)}`);
+    logger.info("Adding Salty-CSS plugin to Next.js config...");
+    await writeFile(configPath, content);
+    await formatWithPrettier(configPath);
+    return { changed: true };
+  }
+};
+const vitePackage = (version) => `@salty-css/vite@${version}`;
+const editViteConfig = (existing) => {
+  if (existing.includes("saltyPlugin")) return { content: null };
+  const pluginImport = "import { saltyPlugin } from '@salty-css/vite';\n";
+  const pluginConfig = "saltyPlugin(__dirname),";
+  const withPlugin = existing.replace(/(plugins: \[)/, `$1
+  ${pluginConfig}`);
+  return { content: pluginImport + withPlugin };
+};
+const viteIntegration = {
+  name: "vite",
+  detect: (ctx) => {
+    const path = join(ctx.projectDir, "vite.config.ts");
+    return existsSync(path) ? path : null;
+  },
+  apply: async (ctx, configPath) => {
+    const existing = await readFile(configPath, "utf-8").catch(() => void 0);
+    if (existing === void 0) return { changed: false };
+    const { content } = editViteConfig(existing);
+    if (content === null) return { changed: false };
+    logger.info("Edit file: " + configPath);
+    if (!ctx.skipInstall) await npmInstall(`-D ${vitePackage(ctx.cliVersion)}`);
+    logger.info("Adding Salty-CSS plugin to Vite config...");
+    await writeFile(configPath, content);
+    await formatWithPrettier(configPath);
+    return { changed: true };
+  }
+};
+const buildIntegrationRegistry = [eslintIntegration, viteIntegration, nextIntegration, astroIntegration];
+const detectAndApplyIntegrations = async (ctx) => {
+  const results = [];
+  for (const integration of buildIntegrationRegistry) {
+    const configPath = await integration.detect(ctx);
+    if (!configPath) continue;
+    const result = await integration.apply(ctx, configPath);
+    results.push({ name: integration.name, configPath, changed: result.changed });
+  }
+  return results;
+};
+const writeProjectFile = async (projectDir, fileName, content) => {
+  const filePath = join(projectDir, fileName);
+  if (existsSync(filePath)) {
+    logger.debug("File already exists: " + filePath);
+    return;
+  }
+  const additionalFolders = fileName.split("/").slice(0, -1).join("/");
+  if (additionalFolders) await mkdir(join(projectDir, additionalFolders), { recursive: true });
+  logger.info("Creating file: " + filePath);
+  await writeFile(filePath, content);
+  await formatWithPrettier(filePath);
+};
+const ensureGitignoreSaltygen = async (rootDir) => {
+  const path = join(rootDir, ".gitignore");
+  const existing = await readFile(path, "utf-8").catch(() => void 0);
+  if (existing === void 0) return;
+  if (existing.includes("saltygen")) return;
+  logger.info("Edit file: " + path);
+  await writeFile(path, existing + "\n\n# Salty-CSS\nsaltygen\n");
+};
+const importSaltygenIntoCss = async (projectDir, explicitCssFile) => {
+  const target = explicitCssFile ?? await findGlobalCssFile(projectDir);
+  if (!target) {
+    logger.warn("Could not find a CSS file to import the generated CSS. Please add it manually.");
+    return;
+  }
+  const cssFilePath = join(projectDir, target);
+  const cssFileContent = await readFile(cssFilePath, "utf-8").catch(() => void 0);
+  if (cssFileContent === void 0) return;
+  if (cssFileContent.includes("saltygen")) return;
+  const cssFileFolder = join(cssFilePath, "..");
+  const relPath = relative(cssFileFolder, join(projectDir, "saltygen/index.css"));
+  logger.info("Adding global import statement to CSS file: " + cssFilePath);
+  await writeFile(cssFilePath, `@import '${relPath}';
+` + cssFileContent);
+  await formatWithPrettier(cssFilePath);
+};
+const wirePrepareScript = async () => {
+  const pkg = await readPackageJson().catch(() => {
+    logError("Could not read package.json file.");
+    return void 0;
+  });
+  if (!pkg) return;
+  const { pkg: next } = addPrepareScript(pkg);
+  await updatePackageJson(next);
+};
+const registerInitCommand = (program) => {
+  program.command("init [directory]").description("Initialize a new Salty-CSS project.").option("-d, --dir <dir>", "Project directory to initialize the project in.").option("--css-file <css-file>", "Existing CSS file where to import the generated CSS. Path must be relative to the given project directory.").option("--skip-install", "Skip installing dependencies.").action(async function(_dir = ".") {
+    try {
+      const opts = this.opts();
+      const dir = opts.dir ?? _dir;
+      if (!dir) return logError("Project directory must be provided. Add it as the first argument after init command or use the --dir option.");
+      const ctx = await buildContext({ dir, skipInstall: opts.skipInstall });
+      logger.info("Initializing a new Salty-CSS project!");
+      const framework = await detectFramework(ctx);
+      logger.info(`Detected framework: ${framework.name}`);
+      if (!ctx.skipInstall) {
+        await npmInstall(corePackages.core(ctx.cliVersion), framework.runtimePackage(ctx.cliVersion));
+      }
+      const projectFiles = await Promise.all([readTemplate("salty.config.ts"), readTemplate("saltygen/index.css")]);
+      await mkdir(ctx.projectDir, { recursive: true });
+      await Promise.all(projectFiles.map(({ fileName, content }) => writeProjectFile(ctx.projectDir, fileName, content)));
+      await writeProjectToRc(ctx.cwd, ctx.relativeProjectPath, framework);
+      await ensureGitignoreSaltygen(ctx.cwd);
+      await importSaltygenIntoCss(ctx.projectDir, opts.cssFile);
+      await detectAndApplyIntegrations(ctx);
+      await wirePrepareScript();
+      logger.info("Running the build to generate initial CSS...");
+      const compiler = new SaltyCompiler(ctx.projectDir);
+      await compiler.generateCss();
+      logger.info("🎉 Salty CSS project initialized successfully!");
+      logger.info("Next steps:");
+      logger.info("1. Configure variables and templates in `salty.config.ts`");
+      logger.info("2. Create a new component with `npx salty-css generate [component-name]`");
+      logger.info("3. Run `npx salty-css build` to generate the CSS");
+      logger.info("4. Read about the features in the documentation: https://salty-css.dev");
+      logger.info("5. Star the project on GitHub: https://github.com/margarita-form/salty-css ⭐");
+    } catch (err) {
+      return logError(err instanceof Error ? err.message : String(err));
+    }
+  });
+};
+const getSaltyCssPackages = async () => {
+  const packageJSONPath = join(process.cwd(), "package.json");
+  const packageJson = await readPackageJson(packageJSONPath).catch((err) => logError(err));
+  if (!packageJson) return logError("Could not read package.json file.");
+  const allDependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+  const saltyCssPackages = Object.entries(allDependencies).filter(([name]) => name === "salty-css" || name.startsWith("@salty-css/"));
+  if (!saltyCssPackages.length) {
+    return logError(
+      "No Salty-CSS packages found in package.json. Make sure you are running update command in the same directory! Used package.json path: " + packageJSONPath
+    );
+  }
+  return saltyCssPackages;
+};
+const registerUpdateCommand = (program) => {
   program.command("update [version]").alias("up").description("Update Salty-CSS packages to the latest or specified version.").option("-v, --version <version>", "Version to update to.").option("--legacy-peer-deps <legacyPeerDeps>", "Use legacy peer dependencies (not recommended).", false).action(async function(_version = "latest") {
     const { legacyPeerDeps, version = _version } = this.opts();
     const saltyCssPackages = await getSaltyCssPackages();
     if (!saltyCssPackages) return logError("Could not update Salty-CSS packages as any were found in package.json.");
+    const cli = await readThisPackageJson();
     const packagesToUpdate = saltyCssPackages.map(([name]) => {
-      if (version === "@") return `${name}@${currentPackageJson.version}`;
+      if (version === "@") return `${name}@${cli.version}`;
       return `${name}@${version.replace(/^@/, "")}`;
     });
     if (legacyPeerDeps) {
@@ -413,19 +619,19 @@ ${eslintConfigContent}`;
     }, {});
     const versionsCount = Object.keys(mappedByVersions).length;
     if (versionsCount === 1) {
-      const version2 = Object.keys(mappedByVersions)[0];
-      const versionString = version2.replace(/^\^/, "");
-      logger.info(`Updated to all Salty CSS packages successfully to ${versionString}`);
+      const v = Object.keys(mappedByVersions)[0];
+      logger.info(`Updated to all Salty CSS packages successfully to ${v.replace(/^\^/, "")}`);
     } else {
-      for (const [version2, names] of Object.entries(mappedByVersions)) {
-        const versionString = version2.replace(/^\^/, "");
-        logger.info(`Updated to ${versionString}: ${names.join(", ")}`);
+      for (const [v, names] of Object.entries(mappedByVersions)) {
+        logger.info(`Updated to ${v.replace(/^\^/, "")}: ${names.join(", ")}`);
       }
     }
   });
+};
+const registerVersionOption = (program) => {
   program.option("-v, --version", "Show the current version of Salty-CSS.").action(async function() {
-    const currentPackageJson2 = await readThisPackageJson();
-    logger.info("CLI is running: " + currentPackageJson2.version);
+    const cli = await readThisPackageJson();
+    logger.info("CLI is running: " + cli.version);
     const packageJSONPath = join(process.cwd(), "package.json");
     const packageJson = await readPackageJson(packageJSONPath).catch((err) => logError(err));
     if (!packageJson) return;
@@ -440,6 +646,16 @@ ${eslintConfigContent}`;
       logger.info(`${dep}: ${allDependencies[dep]}`);
     }
   });
+};
+async function main() {
+  const program = new Command();
+  program.name("salty-css").description("Salty-CSS CLI tool to help with annoying configuration tasks.");
+  const defaultProject = await getDefaultProject();
+  registerInitCommand(program);
+  registerBuildCommand(program, defaultProject);
+  registerGenerateCommand(program, defaultProject);
+  registerUpdateCommand(program);
+  registerVersionOption(program);
   program.parseAsync(process.argv);
 }
 export {