@salty-css/core 0.1.0-alpha.2 → 0.1.0-alpha.21

package/bin/main.cjs

@@ -2,16 +2,46 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const commander = require("commander");
 const fs = require("fs");
-const promises = require("fs/promises");
-const path = require("path");
-const ejs = require("ejs");
-const pascalCase = require("../pascal-case-By_l58S-.cjs");
 const compiler_saltyCompiler = require("../compiler/salty-compiler.cjs");
+const compiler_helpers = require("../compiler/helpers.cjs");
+const shouldRestart = require("../should-restart-CQsyHls3.cjs");
+const path = require("path");
+const promises = require("fs/promises");
 const child_process = require("child_process");
 const ora = require("ora");
-const shouldRestart = require("../should-restart-CQsyHls3.cjs");
-const compiler_helpers = require("../compiler/helpers.cjs");
+const pascalCase = require("../pascal-case-By_l58S-.cjs");
+const ejs = require("ejs");
+const promises$1 = require("readline/promises");
 var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
+const defaultPackageJsonPath = path.join(process.cwd(), "package.json");
+const readPackageJson = async (filePath = defaultPackageJsonPath) => {
+  const content = await promises.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 promises.writeFile(filePath, content);
+};
+const readThisPackageJson = async () => {
+  const packageJsonPath = new URL("../package.json", typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("bin/main.cjs", document.baseURI).href);
+  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) => {
     child_process.exec(command, (error) => {
@@ -40,367 +70,633 @@ async function formatWithPrettier(filePath) {
     compiler_saltyCompiler.logger.error(`Error formatting ${filePath} with Prettier:`, error);
   }
 }
-async function main() {
-  const program = new commander.Command();
-  program.name("salty-css").description("Salty-CSS CLI tool to help with annoying configuration tasks.");
-  const files = {
-    // Core files
-    "salty.config.ts": Promise.resolve().then(() => require("../salty.config-cqavVm2t.cjs")),
-    "saltygen/index.css": Promise.resolve().then(() => require("../index-ByR0nfaf.cjs")),
-    // React
-    "react/react-styled-file.ts": Promise.resolve().then(() => require("../react-styled-file-U02jek-B.cjs")),
-    "react/react-vanilla-file.ts": Promise.resolve().then(() => require("../react-vanilla-file-Bj6XC8GS.cjs"))
-  };
-  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 = path.join(process.cwd(), ".saltyrc.json");
-    const rcContent = await promises.readFile(rcPath, "utf-8").then(JSON.parse).catch(() => ({}));
-    return rcContent;
-  };
-  const defaultPackageJsonPath = path.join(process.cwd(), "package.json");
-  const readPackageJson = async (filePath = defaultPackageJsonPath) => {
-    const packageJsonContent = await promises.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 promises.writeFile(filePath, content);
-  };
-  const readThisPackageJson = async () => {
-    const packageJsonPath = new URL("../package.json", typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("bin/main.cjs", document.baseURI).href);
-    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 = path.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 compiler_saltyCompiler.logError("Salty CSS project must be initialized in a directory with a package.json file.");
-    compiler_saltyCompiler.logger.info("Initializing a new Salty-CSS project!");
-    const { dir = _dir, cssFile, skipInstall } = this.opts();
-    if (!dir) return compiler_saltyCompiler.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 compiler_saltyCompiler.SaltyCompiler(projectDir);
-    await promises.mkdir(projectDir, { recursive: true });
-    const writeFiles = projectFiles.map(async ({ fileName, content }) => {
-      const filePath = path.join(projectDir, fileName);
-      const existingContent = await promises.readFile(filePath, "utf-8").catch(() => void 0);
-      if (existingContent !== void 0) {
-        compiler_saltyCompiler.logger.debug("File already exists: " + filePath);
-        return;
-      }
-      const additionalFolders = fileName.split("/").slice(0, -1).join("/");
-      if (additionalFolders) await promises.mkdir(path.join(projectDir, additionalFolders), { recursive: true });
-      compiler_saltyCompiler.logger.info("Creating file: " + filePath);
-      await promises.writeFile(filePath, content);
-      await formatWithPrettier(filePath);
-    });
-    await Promise.all(writeFiles);
-    const relativeProjectPath = path.relative(rootDir, projectDir) || ".";
-    const saltyrcPath = path.join(rootDir, ".saltyrc.json");
-    const existingSaltyrc = await promises.readFile(saltyrcPath, "utf-8").catch(() => void 0);
-    if (existingSaltyrc === void 0) {
-      compiler_saltyCompiler.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 promises.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) {
-          compiler_saltyCompiler.logger.info("Edit file: " + saltyrcPath);
-          await promises.writeFile(saltyrcPath, content);
-          await formatWithPrettier(saltyrcPath);
-        }
-      }
-    }
-    const gitIgnorePath = path.join(rootDir, ".gitignore");
-    const gitIgnoreContent = await promises.readFile(gitIgnorePath, "utf-8").catch(() => void 0);
-    if (gitIgnoreContent !== void 0) {
-      const alreadyIgnoresSaltygen = gitIgnoreContent.includes("saltygen");
-      if (!alreadyIgnoresSaltygen) {
-        compiler_saltyCompiler.logger.info("Edit file: " + gitIgnorePath);
-        await promises.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 = path.join(projectDir, folder, file + ext);
-            const fileContent = await promises.readFile(filePath, "utf-8").catch(() => void 0);
-            if (fileContent !== void 0) return path.relative(projectDir, filePath);
-            for (const secondLevelFolder of secondLevelFolders) {
-              const filePath2 = path.join(projectDir, folder, secondLevelFolder, file + ext);
-              const fileContent2 = await promises.readFile(filePath2, "utf-8").catch(() => void 0);
-              if (fileContent2 !== void 0) return path.relative(projectDir, filePath2);
-            }
-          }
-        }
-      }
-      return void 0;
-    };
-    const targetCSSFile = await getTargetCssFile();
-    if (targetCSSFile) {
-      const cssFilePath = path.join(projectDir, targetCSSFile);
-      const cssFileContent = await promises.readFile(cssFilePath, "utf-8").catch(() => void 0);
-      if (cssFileContent !== void 0) {
-        const alreadyImportsSaltygen = cssFileContent.includes("saltygen");
-        if (!alreadyImportsSaltygen) {
-          const cssFileFolder = path.join(cssFilePath, "..");
-          const relativePath = path.relative(cssFileFolder, path.join(projectDir, "saltygen/index.css"));
-          const importStatement = `@import '${relativePath}';`;
-          compiler_saltyCompiler.logger.info("Adding global import statement to CSS file: " + cssFilePath);
-          await promises.writeFile(cssFilePath, importStatement + "\n" + cssFileContent);
-          await formatWithPrettier(cssFilePath);
-        }
-      }
-    } else {
-      compiler_saltyCompiler.logger.warn("Could not find a CSS file to import the generated CSS. Please add it manually.");
-    }
-    const eslintConfigs = {
-      projectJs: path.join(projectDir, "eslint.config.js"),
-      rootJs: path.join(rootDir, "eslint.config.js"),
-      projectMjs: path.join(projectDir, "eslint.config.mjs"),
-      rootMjs: path.join(rootDir, "eslint.config.mjs"),
-      projectJson: path.join(projectDir, ".eslintrc.json"),
-      rootJson: path.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()) => path.join(rootDir, SALTYRC_FILENAME);
+const readRc = async (rootDir = process.cwd()) => {
+  const content = await promises.readFile(saltyrcPath(rootDir), "utf-8").then(JSON.parse).catch(() => ({}));
+  return content;
+};
+const readRawRc = async (rootDir = process.cwd()) => {
+  return promises.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 = path.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((path2) => fs.existsSync(path2));
-    if (eslintConfigToUse) {
-      if (!skipInstall) await npmInstall(packages.eslintConfigCore);
-      const eslintConfigContent = await promises.readFile(eslintConfigToUse, "utf-8").catch(() => void 0);
-      if (!eslintConfigContent) return compiler_saltyCompiler.logError("Could not read ESLint config file.");
-      const alreadyHasSaltyConfig = eslintConfigContent.includes("salty-css");
-      if (!alreadyHasSaltyConfig) {
-        compiler_saltyCompiler.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 compiler_saltyCompiler.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 compiler_saltyCompiler.logger.warn("Could not find the correct place to add the Salty-CSS config for ESLint. Please add it manually.");
-          }
-          await promises.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 promises.writeFile(eslintConfigToUse, modifiedEslintConfigContent);
-          await formatWithPrettier(eslintConfigToUse);
-        }
-      }
-    }
-    const viteConfigPath = path.join(projectDir, "vite.config.ts");
-    const viteConfigContent = await promises.readFile(viteConfigPath, "utf-8").catch(() => void 0);
-    if (viteConfigContent !== void 0) {
-      const alreadyHasPlugin = viteConfigContent.includes("saltyPlugin");
-      if (!alreadyHasPlugin) {
-        compiler_saltyCompiler.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}`);
-        compiler_saltyCompiler.logger.info("Adding Salty-CSS plugin to Vite config...");
-        await promises.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) => path.join(projectDir, file)).find((path2) => fs.existsSync(path2));
-    if (nextConfigPath) {
-      let nextConfigContent = await promises.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}`);
-          compiler_saltyCompiler.logger.info("Adding Salty-CSS plugin to Next.js config...");
-          await promises.writeFile(nextConfigPath, pluginImport + nextConfigContent);
-          await formatWithPrettier(nextConfigPath);
-        }
-      }
-    }
-    const packageJsonContent = await readPackageJson().catch(() => compiler_saltyCompiler.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) {
-          compiler_saltyCompiler.logger.info("Edit file: " + defaultPackageJsonPath);
-          content.scripts.prepare = content.scripts.prepare + " && npx salty-css build";
-        }
-      } else {
-        compiler_saltyCompiler.logger.info("Edit file: " + defaultPackageJsonPath);
-        content.scripts.prepare = "npx salty-css build";
-      }
-      return content;
-    });
-    await updatePackageJson(packageJsonContent);
-    compiler_saltyCompiler.logger.info("Running the build to generate initial CSS...");
-    await saltyCompiler.generateCss();
-    compiler_saltyCompiler.logger.info("🎉 Salty CSS project initialized successfully!");
-    compiler_saltyCompiler.logger.info("Next steps:");
-    compiler_saltyCompiler.logger.info("1. Configure variables and templates in `salty.config.ts`");
-    compiler_saltyCompiler.logger.info("2. Create a new component with `npx salty-css generate [component-name]`");
-    compiler_saltyCompiler.logger.info("3. Run `npx salty-css build` to generate the CSS");
-    compiler_saltyCompiler.logger.info("4. Read about the features in the documentation: https://salty-css.dev");
-    compiler_saltyCompiler.logger.info("5. Star the project on GitHub: https://github.com/margarita-form/salty-css ⭐");
-  });
-  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) {
+    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 path2 = saltyrcPath(cwd);
+  const existing = await readRawRc(cwd);
+  const { content, changed, created } = upsertProjectInRc(existing, relativeProjectPath, framework);
+  if (!changed) return false;
+  if (created) compiler_saltyCompiler.logger.info("Creating file: " + path2);
+  else compiler_saltyCompiler.logger.info("Edit file: " + path2);
+  await promises.writeFile(path2, content);
+  await formatWithPrettier(path2);
+  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 path.join(rootDir, dirName);
+};
+const buildContext = async (opts) => {
+  const cwd = process.cwd();
+  const projectDir = resolveProjectDir(opts.dir, cwd);
+  const relativeProjectPath = path.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,
+    yes: !!opts.yes
+  };
+};
+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.").option("--mode <mode>", 'Build mode: "production" or "development". Defaults to NODE_ENV-based detection.').action(async function(_dir = defaultProject) {
     compiler_saltyCompiler.logger.info("Building the Salty-CSS project...");
-    const { dir = _dir, watch } = this.opts();
-    if (!dir) return compiler_saltyCompiler.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 compiler_saltyCompiler.SaltyCompiler(projectDir);
-    await saltyCompiler.generateCss();
+    const { dir = _dir, watch, mode } = this.opts();
+    if (mode !== void 0 && mode !== "production" && mode !== "development") {
+      return compiler_saltyCompiler.logError(`Invalid --mode "${mode}". Expected "production" or "development".`);
+    }
+    const resolved = dir ?? await getDefaultProject();
+    if (!resolved) return compiler_saltyCompiler.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 compiler_saltyCompiler.SaltyCompiler(projectDir, { mode });
+    await compiler.generateCss();
     if (watch) {
       compiler_saltyCompiler.logger.info("Watching for changes in the project directory...");
-      fs.watch(projectDir, { recursive: true }, async (event, filePath) => {
+      fs.watch(projectDir, { recursive: true }, async (_event, filePath) => {
         const shouldRestart$1 = await shouldRestart.checkShouldRestart(filePath);
         if (shouldRestart$1) {
-          await saltyCompiler.generateCss(false);
-        } else {
-          const saltyFile = compiler_helpers.isSaltyFile(filePath);
-          if (saltyFile) await saltyCompiler.generateFile(filePath);
+          await compiler.generateCss(false);
+        } else if (compiler_helpers.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$1 = path.join(projectDir, name);
+    if (fs.existsSync(path$1)) return path$1;
+  }
+  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": () => Promise.resolve().then(() => require("../salty.config-DogY_sSQ.cjs")),
+  "saltygen/index.css": () => Promise.resolve().then(() => require("../index-ByR0nfaf.cjs")),
+  "react/styled-file.ts": () => Promise.resolve().then(() => require("../styled-file-CPd_rTW2.cjs")),
+  "react/vanilla-file.ts": () => Promise.resolve().then(() => require("../vanilla-file-r0fp2q_m.cjs")),
+  "astro/styled-file.ts": () => Promise.resolve().then(() => require("../styled-file-BzmB9_Ez.cjs")),
+  "astro/component.astro": () => Promise.resolve().then(() => require("../astro-component-Dj3enX6K.cjs"))
+};
+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 compiler_saltyCompiler.logError("File to generate must be provided. Add it as the first argument after generate command or use the --file option.");
     if (!dir) return compiler_saltyCompiler.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 compiler_saltyCompiler.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 promises.mkdir(path.join(projectDir, additionalFolders), { recursive: true });
-    const filePath = path.join(projectDir, file);
+    if (additionalFolders) await promises.mkdir(path.join(ctx.projectDir, additionalFolders), { recursive: true });
+    const filePath = path.join(ctx.projectDir, file);
     const parsedFilePath = path.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 = path.format(parsedFilePath);
     const alreadyExists = await promises.readFile(formattedStyledFilePath, "utf-8").catch(() => void 0);
     if (alreadyExists !== void 0) {
-      compiler_saltyCompiler.logger.error("File already exists:", formattedStyledFilePath);
+      compiler_saltyCompiler.logger.error("File already exists: " + formattedStyledFilePath);
       return;
     }
     let styledComponentName = pascalCase.pascalCase(name || parsedFilePath.base.replace(/\.css\.\w+$/, ""));
     if (reactComponent) {
+      if (!framework.templates.component) {
+        return compiler_saltyCompiler.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 = path.format(parsedFilePath);
-      compiler_saltyCompiler.logger.info("Generating a new file: " + formattedReactFilePath);
-      await promises.writeFile(formattedReactFilePath, reactContent);
-      await formatWithPrettier(formattedReactFilePath);
+      const formattedWrapperPath = path.format(parsedFilePath);
+      compiler_saltyCompiler.logger.info("Generating a new file: " + formattedWrapperPath);
+      await promises.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 });
     compiler_saltyCompiler.logger.info("Generating a new file: " + formattedStyledFilePath);
     await promises.writeFile(formattedStyledFilePath, content);
     await formatWithPrettier(formattedStyledFilePath);
   });
-  const getSaltyCssPackages = async () => {
-    const packageJSONPath = path.join(process.cwd(), "package.json");
-    const packageJson = await readPackageJson(packageJSONPath).catch((err) => compiler_saltyCompiler.logError(err));
-    if (!packageJson) return compiler_saltyCompiler.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 compiler_saltyCompiler.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 formatPackageForDisplay = (spec) => {
+  const trimmed = spec.trim();
+  if (trimmed.startsWith("-D ")) return `${trimmed.slice(3).trim()} (dev)`;
+  return trimmed;
+};
+const renderPackageList = (packages) => {
+  return packages.map((p) => `  + ${formatPackageForDisplay(p)}`).join("\n");
+};
+const confirmInstall = async (packages, yes, options = {}) => {
+  if (yes) return;
+  if (packages.length === 0) return;
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const isTTY = options.isTTY ?? process.stdin.isTTY ?? false;
+  if (!isTTY) {
+    throw new Error("Cannot prompt for install confirmation: stdin is not a TTY. Re-run with --yes to install the listed packages without prompting.");
+  }
+  output.write(`The following packages will be installed:
+${renderPackageList(packages)}
+`);
+  const rl = promises$1.createInterface({ input, output, terminal: false });
+  try {
+    const answer = (await rl.question("Proceed? (y/N) ")).trim().toLowerCase();
+    if (answer !== "y" && answer !== "yes") {
+      throw new Error("Install cancelled by user.");
     }
-    return saltyCssPackages;
-  };
-  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();
+  } finally {
+    rl.close();
+  }
+};
+const confirmYesNo = async (question, options = {}) => {
+  if (options.yes) return true;
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const isTTY = options.isTTY ?? process.stdin.isTTY ?? false;
+  if (!isTTY) return false;
+  const suffix = options.defaultYes ? "(Y/n)" : "(y/N)";
+  const rl = promises$1.createInterface({ input, output, terminal: false });
+  try {
+    const answer = (await rl.question(`${question} ${suffix} `)).trim().toLowerCase();
+    if (answer === "") return !!options.defaultYes;
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+};
+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 = path.join(projectDir, folder, file + ext);
+        const fileContent = await promises.readFile(filePath, "utf-8").catch(() => void 0);
+        if (fileContent !== void 0) return path.relative(projectDir, filePath);
+        for (const second of CSS_SECOND_LEVEL_FOLDERS) {
+          const nestedPath = path.join(projectDir, folder, second, file + ext);
+          const nestedContent = await promises.readFile(nestedPath, "utf-8").catch(() => void 0);
+          if (nestedContent !== void 0) return path.relative(projectDir, nestedPath);
+        }
+      }
+    }
+  }
+  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),
+  plan: async (ctx, configPath) => {
+    const existing = await promises.readFile(configPath, "utf-8").catch(() => void 0);
+    if (existing === void 0) return null;
+    const result = editAstroConfig(existing);
+    if (result.warning) compiler_saltyCompiler.logger.warn(result.warning);
+    if (result.content === null) return null;
+    const newContent = result.content;
+    return {
+      packages: [`-D ${astroPackage(ctx.cliVersion)}`],
+      execute: async () => {
+        compiler_saltyCompiler.logger.info("Adding Salty-CSS integration to Astro config: " + configPath);
+        await promises.writeFile(configPath, newContent);
+        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 path.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) => fs.existsSync(p)) ?? null;
+  },
+  plan: async (ctx, configPath) => {
+    const existing = await promises.readFile(configPath, "utf-8").catch(() => void 0);
+    if (existing === void 0) {
+      compiler_saltyCompiler.logger.error("Could not read ESLint config file.");
+      return null;
+    }
+    const result = editEslintConfig(existing, configPath.endsWith("js"));
+    if (result.warning) compiler_saltyCompiler.logger.warn(result.warning);
+    if (result.content === null) return null;
+    const newContent = result.content;
+    return {
+      packages: [corePackages.eslintConfigCore(ctx.cliVersion)],
+      execute: async () => {
+        compiler_saltyCompiler.logger.info("Edit file: " + configPath);
+        await promises.writeFile(configPath, newContent);
+        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) => path.join(ctx.projectDir, file)).find((p) => fs.existsSync(p));
+    return found ?? null;
+  },
+  plan: async (ctx, configPath) => {
+    const existing = await promises.readFile(configPath, "utf-8").catch(() => void 0);
+    if (existing === void 0) return null;
+    const { content } = editNextConfig(existing);
+    if (content === null) return null;
+    return {
+      packages: [`-D ${nextPackage(ctx.cliVersion)}`],
+      execute: async () => {
+        compiler_saltyCompiler.logger.info("Adding Salty-CSS plugin to Next.js config...");
+        await promises.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$1 = path.join(ctx.projectDir, "vite.config.ts");
+    return fs.existsSync(path$1) ? path$1 : null;
+  },
+  plan: async (ctx, configPath) => {
+    const existing = await promises.readFile(configPath, "utf-8").catch(() => void 0);
+    if (existing === void 0) return null;
+    const { content } = editViteConfig(existing);
+    if (content === null) return null;
+    return {
+      packages: [`-D ${vitePackage(ctx.cliVersion)}`],
+      execute: async () => {
+        compiler_saltyCompiler.logger.info("Edit file: " + configPath);
+        compiler_saltyCompiler.logger.info("Adding Salty-CSS plugin to Vite config...");
+        await promises.writeFile(configPath, content);
+        await formatWithPrettier(configPath);
+        return { changed: true };
+      }
+    };
+  }
+};
+const buildIntegrationRegistry = [eslintIntegration, viteIntegration, nextIntegration, astroIntegration];
+const planIntegrations = async (ctx) => {
+  const planned = [];
+  for (const integration of buildIntegrationRegistry) {
+    const configPath = await integration.detect(ctx);
+    if (!configPath) continue;
+    const plan = await integration.plan(ctx, configPath);
+    if (!plan) continue;
+    planned.push({ name: integration.name, configPath, plan });
+  }
+  return planned;
+};
+const applyIntegrationPlans = async (planned) => {
+  const results = [];
+  for (const { name, configPath, plan } of planned) {
+    const result = await plan.execute();
+    results.push({ name, configPath, changed: result.changed });
+  }
+  return results;
+};
+const writeProjectFile = async (projectDir, fileName, content) => {
+  const filePath = path.join(projectDir, fileName);
+  if (fs.existsSync(filePath)) {
+    compiler_saltyCompiler.logger.debug("File already exists: " + filePath);
+    return;
+  }
+  const additionalFolders = fileName.split("/").slice(0, -1).join("/");
+  if (additionalFolders) await promises.mkdir(path.join(projectDir, additionalFolders), { recursive: true });
+  compiler_saltyCompiler.logger.info("Creating file: " + filePath);
+  await promises.writeFile(filePath, content);
+  await formatWithPrettier(filePath);
+};
+const ensureGitignoreSaltygen = async (rootDir) => {
+  const path$1 = path.join(rootDir, ".gitignore");
+  const existing = await promises.readFile(path$1, "utf-8").catch(() => void 0);
+  if (existing === void 0) return;
+  if (existing.includes("saltygen")) return;
+  compiler_saltyCompiler.logger.info("Edit file: " + path$1);
+  await promises.writeFile(path$1, existing + "\n\n# Salty-CSS\nsaltygen\n");
+};
+const importSaltygenIntoCss = async (projectDir, explicitCssFile) => {
+  const target = explicitCssFile ?? await findGlobalCssFile(projectDir);
+  if (!target) {
+    compiler_saltyCompiler.logger.warn("Could not find a CSS file to import the generated CSS. Please add it manually.");
+    return;
+  }
+  const cssFilePath = path.join(projectDir, target);
+  const cssFileContent = await promises.readFile(cssFilePath, "utf-8").catch(() => void 0);
+  if (cssFileContent === void 0) return;
+  if (cssFileContent.includes("saltygen")) return;
+  const cssFileFolder = path.join(cssFilePath, "..");
+  const relPath = path.relative(cssFileFolder, path.join(projectDir, "saltygen/index.css"));
+  compiler_saltyCompiler.logger.info("Adding global import statement to CSS file: " + cssFilePath);
+  await promises.writeFile(cssFilePath, `@import '${relPath}';
+` + cssFileContent);
+  await formatWithPrettier(cssFilePath);
+};
+const wirePrepareScript = async () => {
+  const pkg = await readPackageJson().catch(() => {
+    compiler_saltyCompiler.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.").option("-y, --yes", "Skip the install confirmation prompt.").action(async function(_dir = ".") {
+    try {
+      const opts = this.opts();
+      const dir = opts.dir ?? _dir;
+      if (!dir) return compiler_saltyCompiler.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, yes: opts.yes });
+      compiler_saltyCompiler.logger.info("Initializing a new Salty-CSS project!");
+      const framework = await detectFramework(ctx);
+      compiler_saltyCompiler.logger.info(`Detected framework: ${framework.name}`);
+      const plannedIntegrations = await planIntegrations(ctx);
+      if (!ctx.skipInstall) {
+        const packages = [
+          corePackages.core(ctx.cliVersion),
+          framework.runtimePackage(ctx.cliVersion),
+          ...plannedIntegrations.flatMap((p) => p.plan.packages)
+        ];
+        await confirmInstall(packages, ctx.yes);
+        await npmInstall(...packages);
+      }
+      const projectFiles = await Promise.all([readTemplate("salty.config.ts"), readTemplate("saltygen/index.css")]);
+      await promises.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 applyIntegrationPlans(plannedIntegrations);
+      await wirePrepareScript();
+      compiler_saltyCompiler.logger.info("Running the build to generate initial CSS...");
+      const compiler = new compiler_saltyCompiler.SaltyCompiler(ctx.projectDir);
+      await compiler.generateCss();
+      compiler_saltyCompiler.logger.info("🎉 Salty CSS project initialized successfully!");
+      compiler_saltyCompiler.logger.info("Next steps:");
+      compiler_saltyCompiler.logger.info("1. Configure variables and templates in `salty.config.ts`");
+      compiler_saltyCompiler.logger.info("2. Create a new component with `npx salty-css generate [component-name]`");
+      compiler_saltyCompiler.logger.info("3. Run `npx salty-css build` to generate the CSS");
+      compiler_saltyCompiler.logger.info("4. Read about the features in the documentation: https://salty-css.dev");
+      compiler_saltyCompiler.logger.info("5. Star the project on GitHub: https://github.com/margarita-form/salty-css ⭐");
+    } catch (err) {
+      return compiler_saltyCompiler.logError(err instanceof Error ? err.message : String(err));
+    }
+  });
+};
+const getSaltyCssPackages = async () => {
+  const packageJSONPath = path.join(process.cwd(), "package.json");
+  const packageJson = await readPackageJson(packageJSONPath).catch((err) => compiler_saltyCompiler.logError(err));
+  if (!packageJson) return compiler_saltyCompiler.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 compiler_saltyCompiler.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).option("-y, --yes", "Skip confirmation prompts (install and rebuild).").option("-d, --dir <dir>", "Project directory to rebuild after updating.").action(async function(_version = "latest") {
+    const { legacyPeerDeps, version = _version, yes = false, dir } = this.opts();
     const saltyCssPackages = await getSaltyCssPackages();
     if (!saltyCssPackages) return compiler_saltyCompiler.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(/^@/, "")}`;
     });
+    try {
+      await confirmInstall(packagesToUpdate, yes);
+    } catch (err) {
+      return compiler_saltyCompiler.logError(err instanceof Error ? err.message : String(err));
+    }
     if (legacyPeerDeps) {
       compiler_saltyCompiler.logger.warn("Using legacy peer dependencies to update packages.");
       await npmInstall(...packagesToUpdate, "--legacy-peer-deps");
@@ -416,19 +712,30 @@ ${eslintConfigContent}`;
     }, {});
     const versionsCount = Object.keys(mappedByVersions).length;
     if (versionsCount === 1) {
-      const version2 = Object.keys(mappedByVersions)[0];
-      const versionString = version2.replace(/^\^/, "");
-      compiler_saltyCompiler.logger.info(`Updated to all Salty CSS packages successfully to ${versionString}`);
+      const v = Object.keys(mappedByVersions)[0];
+      compiler_saltyCompiler.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(/^\^/, "");
-        compiler_saltyCompiler.logger.info(`Updated to ${versionString}: ${names.join(", ")}`);
+      for (const [v, names] of Object.entries(mappedByVersions)) {
+        compiler_saltyCompiler.logger.info(`Updated to ${v.replace(/^\^/, "")}: ${names.join(", ")}`);
       }
     }
+    const project = dir ?? await getDefaultProject();
+    if (!project) {
+      compiler_saltyCompiler.logger.warn("Skipping rebuild: no project directory configured. Run `salty-css build [dir]` manually.");
+      return;
+    }
+    const shouldRebuild = await confirmYesNo("Rebuild Salty CSS now?", { yes });
+    if (!shouldRebuild) return;
+    const projectDir = resolveProjectDir(project);
+    compiler_saltyCompiler.logger.info("Rebuilding Salty-CSS project...");
+    await new compiler_saltyCompiler.SaltyCompiler(projectDir).generateCss();
+    compiler_saltyCompiler.logger.info("Rebuild complete.");
   });
+};
+const registerVersionOption = (program) => {
   program.option("-v, --version", "Show the current version of Salty-CSS.").action(async function() {
-    const currentPackageJson2 = await readThisPackageJson();
-    compiler_saltyCompiler.logger.info("CLI is running: " + currentPackageJson2.version);
+    const cli = await readThisPackageJson();
+    compiler_saltyCompiler.logger.info("CLI is running: " + cli.version);
     const packageJSONPath = path.join(process.cwd(), "package.json");
     const packageJson = await readPackageJson(packageJSONPath).catch((err) => compiler_saltyCompiler.logError(err));
     if (!packageJson) return;
@@ -443,6 +750,16 @@ ${eslintConfigContent}`;
       compiler_saltyCompiler.logger.info(`${dep}: ${allDependencies[dep]}`);
     }
   });
+};
+async function main() {
+  const program = new commander.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);
 }
 exports.main = main;