@salty-css/core 0.1.0-alpha.9 → 0.1.0-refactor-add-additional-paths-to-config-cache.0

package/bin/confirm-install.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Renders a single package spec for display. Translates the internal
+ * `'-D <pkg>@<ver>'` shorthand used by `npmInstall` into a `<pkg>@<ver> (dev)`
+ * suffix so the user-facing list reads naturally.
+ */
+export declare const formatPackageForDisplay: (spec: string) => string;
+export declare const renderPackageList: (packages: string[]) => string;
+export interface ConfirmInstallOptions {
+    /** Streams used for the prompt — defaults to process.stdin/stdout. Allows tests to inject. */
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+    /** Whether the input is a TTY — defaults to process.stdin.isTTY. Allows tests to override. */
+    isTTY?: boolean;
+}
+/**
+ * Confirm a batched install. Resolves on success, throws on decline.
+ *
+ * - `yes=true` or empty `packages` → no prompt, resolves immediately.
+ * - Non-TTY without `yes` → throws, telling the user to pass `--yes`.
+ * - Otherwise prints the list and asks `Proceed? (y/N)`. Accepts y/yes
+ *   (case-insensitive); anything else throws to abort the command.
+ */
+export declare const confirmInstall: (packages: string[], yes: boolean, options?: ConfirmInstallOptions) => Promise<void>;
+export interface ConfirmYesNoOptions extends ConfirmInstallOptions {
+    /** When true, resolves true without prompting. */
+    yes?: boolean;
+    /** When true, an empty answer counts as yes. Defaults to false (empty = no). */
+    defaultYes?: boolean;
+}
+/**
+ * Generic yes/no prompt. Unlike `confirmInstall`, non-TTY without `yes`
+ * resolves `false` instead of throwing — callers can choose policy.
+ */
+export declare const confirmYesNo: (question: string, options?: ConfirmYesNoOptions) => Promise<boolean>;

package/bin/context.d.ts

@@ -8,11 +8,14 @@ export interface ProjectContext {
     rcFile: RCFile;
     cliVersion: string;
     skipInstall: boolean;
+    yes: boolean;
 }
 export declare const resolveProjectDir: (dir: string, rootDir?: string) => string;
 export interface BuildContextOptions {
     dir: string;
     skipInstall?: boolean;
+    /** Skip the install confirmation prompt and install without asking. */
+    yes?: boolean;
     /** When false, build context even if package.json is missing (used by commands that should not require one). */
     requirePackageJson?: boolean;
 }

package/bin/integrations/index.d.ts

@@ -1,12 +1,20 @@
 import { ProjectContext } from '../context';
-import { BuildIntegrationAdapter } from './types';
+import { BuildIntegrationAdapter, IntegrationPlan } from './types';
 export declare const buildIntegrationRegistry: BuildIntegrationAdapter[];
-export declare const detectAndApplyIntegrations: (ctx: ProjectContext) => Promise<{
+export interface PlannedIntegration {
+    name: string;
+    configPath: string;
+    plan: IntegrationPlan;
+}
+/** Detect every integration that has work to do and compute its plan. */
+export declare const planIntegrations: (ctx: ProjectContext) => Promise<PlannedIntegration[]>;
+/** Execute each previously-planned integration (writes config files). */
+export declare const applyIntegrationPlans: (planned: PlannedIntegration[]) => Promise<{
     name: string;
     configPath: string;
     changed: boolean;
 }[]>;
-export type { BuildIntegrationAdapter, ConfigEdit } from './types';
+export type { BuildIntegrationAdapter, ConfigEdit, IntegrationPlan } from './types';
 export { viteIntegration, editViteConfig, vitePackage } from './vite';
 export { nextIntegration, editNextConfig, nextPackage, nextConfigFiles } from './next';
 export { astroIntegration, editAstroConfig, astroPackage } from './astro';

package/bin/integrations/types.d.ts

@@ -3,12 +3,24 @@ export interface IntegrationApplyResult {
     /** Whether any file was edited or any install was performed. */
     changed: boolean;
 }
+/**
+ * Pending integration work — the packages it would like installed and a
+ * closure that writes the config edits once the install (if any) has run.
+ */
+export interface IntegrationPlan {
+    /** Packages to install, using the same `npmInstall` shorthand (e.g. `'-D @salty-css/vite@1.2.3'`). */
+    packages: string[];
+    execute(): Promise<IntegrationApplyResult>;
+}
 export interface BuildIntegrationAdapter {
     name: string;
     /** Returns the config file path this integration targets, or null when not applicable. */
     detect(ctx: ProjectContext): Promise<string | null> | string | null;
-    /** Idempotently wire the integration into the project (edit configs, install dev deps). */
-    apply(ctx: ProjectContext, configPath: string): Promise<IntegrationApplyResult>;
+    /**
+     * Idempotently produce the work needed to wire the integration in. Returns
+     * null when the integration is already wired (nothing to do).
+     */
+    plan(ctx: ProjectContext, configPath: string): Promise<IntegrationPlan | null>;
 }
 /** Pure transform — returned by an integration when it knows how to rewrite a config file. */
 export interface ConfigEdit {

package/bin/main.cjs

@@ -9,8 +9,10 @@ const path = require("path");
 const promises = require("fs/promises");
 const child_process = require("child_process");
 const ora = require("ora");
+const logger = require("../logger-7xz0pyAz.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) => {
@@ -64,9 +66,9 @@ async function formatWithPrettier(filePath) {
     const hasPrettier = hasPrettierInstalled();
     if (!hasPrettier) return;
     await execAsync(`./node_modules/.bin/prettier --write "${filePath}"`);
-    compiler_saltyCompiler.logger.info(`Formatted ${filePath} with Prettier`);
+    logger.logger.info(`Formatted ${filePath} with Prettier`);
   } catch (error) {
-    compiler_saltyCompiler.logger.error(`Error formatting ${filePath} with Prettier:`, error);
+    logger.logger.error(`Error formatting ${filePath} with Prettier:`, error);
   }
 }
 const SALTYRC_FILENAME = ".saltyrc.json";
@@ -109,8 +111,8 @@ const writeProjectToRc = async (cwd, relativeProjectPath, framework) => {
   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);
+  if (created) logger.logger.info("Creating file: " + path2);
+  else logger.logger.info("Edit file: " + path2);
   await promises.writeFile(path2, content);
   await formatWithPrettier(path2);
   return true;
@@ -141,20 +143,24 @@ const buildContext = async (opts) => {
     packageJson,
     rcFile,
     cliVersion: cliPackageJson.version || "0.0.0",
-    skipInstall: !!opts.skipInstall
+    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.").action(async function(_dir = defaultProject) {
-    compiler_saltyCompiler.logger.info("Building the Salty-CSS project...");
-    const { dir = _dir, watch } = this.opts();
+  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) {
+    logger.logger.info("Building the Salty-CSS project...");
+    const { dir = _dir, watch, mode } = this.opts();
+    if (mode !== void 0 && mode !== "production" && mode !== "development") {
+      return logger.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.");
+    if (!resolved) return logger.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);
+    const compiler = new compiler_saltyCompiler.SaltyCompiler(projectDir, { mode });
     await compiler.generateCss();
     if (watch) {
-      compiler_saltyCompiler.logger.info("Watching for changes in the project directory...");
+      logger.logger.info("Watching for changes in the project directory...");
       fs.watch(projectDir, { recursive: true }, async (_event, filePath) => {
         const shouldRestart$1 = await shouldRestart.checkShouldRestart(filePath);
         if (shouldRestart$1) {
@@ -225,7 +231,7 @@ const getFramework = (name) => {
   return frameworksByName[name];
 };
 const templateLoaders = {
-  "salty.config.ts": () => Promise.resolve().then(() => require("../salty.config-cqavVm2t.cjs")),
+  "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")),
@@ -240,13 +246,13 @@ const readTemplate = async (key, options) => {
 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.");
+    if (!file) return logger.logError("File to generate must be provided. Add it as the first argument after generate command or use the --file option.");
+    if (!dir) return logger.logError("Project directory must be provided. Add it as the second argument after generate command or use the --dir option.");
     let ctx;
     try {
       ctx = await buildContext({ dir, requirePackageJson: false });
     } catch (err) {
-      return compiler_saltyCompiler.logError(err instanceof Error ? err.message : String(err));
+      return logger.logError(err instanceof Error ? err.message : String(err));
     }
     const rcFramework = getFramework(getProjectFramework(ctx.rcFile, ctx.relativeProjectPath));
     const framework = rcFramework ?? await detectFramework(ctx);
@@ -260,13 +266,13 @@ const registerGenerateCommand = (program, defaultProject) => {
     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);
+      logger.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.`);
+        return logger.logError(`--reactComponent is not supported for the ${framework.name} framework.`);
       }
       const componentName = styledComponentName + "Component";
       styledComponentName = styledComponentName + "Wrapper";
@@ -282,17 +288,63 @@ const registerGenerateCommand = (program, defaultProject) => {
       parsedFilePath.ext = framework.templates.component.wrapperExt;
       parsedFilePath.base = parsedFilePath.name + parsedFilePath.ext;
       const formattedWrapperPath = path.format(parsedFilePath);
-      compiler_saltyCompiler.logger.info("Generating a new file: " + formattedWrapperPath);
+      logger.logger.info("Generating a new file: " + formattedWrapperPath);
       await promises.writeFile(formattedWrapperPath, wrapperContent);
       await formatWithPrettier(formattedWrapperPath);
     }
     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);
+    logger.logger.info("Generating a new file: " + formattedStyledFilePath);
     await promises.writeFile(formattedStyledFilePath, content);
     await formatWithPrettier(formattedStyledFilePath);
   });
 };
+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.");
+    }
+  } 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"];
@@ -339,17 +391,22 @@ const editAstroConfig = (existing) => {
 const astroIntegration = {
   name: "astro",
   detect: (ctx) => findAstroConfig(ctx.projectDir),
-  apply: async (ctx, configPath) => {
+  plan: async (ctx, configPath) => {
     const existing = await promises.readFile(configPath, "utf-8").catch(() => void 0);
-    if (existing === void 0) return { changed: false };
+    if (existing === void 0) return null;
     const result = editAstroConfig(existing);
-    if (result.warning) compiler_saltyCompiler.logger.warn(result.warning);
-    if (result.content === null) return { changed: false };
-    if (!ctx.skipInstall) await npmInstall(`-D ${astroPackage(ctx.cliVersion)}`);
-    compiler_saltyCompiler.logger.info("Adding Salty-CSS integration to Astro config: " + configPath);
-    await promises.writeFile(configPath, result.content);
-    await formatWithPrettier(configPath);
-    return { changed: true };
+    if (result.warning) logger.logger.warn(result.warning);
+    if (result.content === null) return null;
+    const newContent = result.content;
+    return {
+      packages: [`-D ${astroPackage(ctx.cliVersion)}`],
+      execute: async () => {
+        logger.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 = [
@@ -408,20 +465,25 @@ const eslintIntegration = {
     const candidates = eslintConfigCandidates(ctx.projectDir, ctx.cwd);
     return candidates.find((p) => fs.existsSync(p)) ?? null;
   },
-  apply: async (ctx, configPath) => {
+  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 { changed: false };
+      logger.logger.error("Could not read ESLint config file.");
+      return null;
     }
-    if (!ctx.skipInstall) await npmInstall(corePackages.eslintConfigCore(ctx.cliVersion));
     const result = editEslintConfig(existing, configPath.endsWith("js"));
-    if (result.warning) compiler_saltyCompiler.logger.warn(result.warning);
-    if (result.content === null) return { changed: false };
-    compiler_saltyCompiler.logger.info("Edit file: " + configPath);
-    await promises.writeFile(configPath, result.content);
-    await formatWithPrettier(configPath);
-    return { changed: true };
+    if (result.warning) logger.logger.warn(result.warning);
+    if (result.content === null) return null;
+    const newContent = result.content;
+    return {
+      packages: [corePackages.eslintConfigCore(ctx.cliVersion)],
+      execute: async () => {
+        logger.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"];
@@ -451,16 +513,20 @@ const nextIntegration = {
     const found = nextConfigFiles.map((file) => path.join(ctx.projectDir, file)).find((p) => fs.existsSync(p));
     return found ?? null;
   },
-  apply: async (ctx, configPath) => {
+  plan: async (ctx, configPath) => {
     const existing = await promises.readFile(configPath, "utf-8").catch(() => void 0);
-    if (existing === void 0) return { changed: false };
+    if (existing === void 0) return null;
     const { content } = editNextConfig(existing);
-    if (content === null) return { changed: false };
-    if (!ctx.skipInstall) await npmInstall(`-D ${nextPackage(ctx.cliVersion)}`);
-    compiler_saltyCompiler.logger.info("Adding Salty-CSS plugin to Next.js config...");
-    await promises.writeFile(configPath, content);
-    await formatWithPrettier(configPath);
-    return { changed: true };
+    if (content === null) return null;
+    return {
+      packages: [`-D ${nextPackage(ctx.cliVersion)}`],
+      execute: async () => {
+        logger.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}`;
@@ -478,39 +544,52 @@ const viteIntegration = {
     const path$1 = path.join(ctx.projectDir, "vite.config.ts");
     return fs.existsSync(path$1) ? path$1 : null;
   },
-  apply: async (ctx, configPath) => {
+  plan: async (ctx, configPath) => {
     const existing = await promises.readFile(configPath, "utf-8").catch(() => void 0);
-    if (existing === void 0) return { changed: false };
+    if (existing === void 0) return null;
     const { content } = editViteConfig(existing);
-    if (content === null) return { changed: false };
-    compiler_saltyCompiler.logger.info("Edit file: " + configPath);
-    if (!ctx.skipInstall) await npmInstall(`-D ${vitePackage(ctx.cliVersion)}`);
-    compiler_saltyCompiler.logger.info("Adding Salty-CSS plugin to Vite config...");
-    await promises.writeFile(configPath, content);
-    await formatWithPrettier(configPath);
-    return { changed: true };
+    if (content === null) return null;
+    return {
+      packages: [`-D ${vitePackage(ctx.cliVersion)}`],
+      execute: async () => {
+        logger.logger.info("Edit file: " + configPath);
+        logger.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 detectAndApplyIntegrations = async (ctx) => {
-  const results = [];
+const planIntegrations = async (ctx) => {
+  const planned = [];
   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 });
+    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);
+    logger.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);
+  logger.logger.info("Creating file: " + filePath);
   await promises.writeFile(filePath, content);
   await formatWithPrettier(filePath);
 };
@@ -519,13 +598,13 @@ const ensureGitignoreSaltygen = async (rootDir) => {
   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);
+  logger.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.");
+    logger.logger.warn("Could not find a CSS file to import the generated CSS. Please add it manually.");
     return;
   }
   const cssFilePath = path.join(projectDir, target);
@@ -534,14 +613,14 @@ const importSaltygenIntoCss = async (projectDir, explicitCssFile) => {
   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);
+  logger.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.");
+    logger.logError("Could not read package.json file.");
     return void 0;
   });
   if (!pkg) return;
@@ -549,17 +628,24 @@ const wirePrepareScript = async () => {
   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 = ".") {
+  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 });
-      compiler_saltyCompiler.logger.info("Initializing a new Salty-CSS project!");
+      if (!dir) return logger.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 });
+      logger.logger.info("Initializing a new Salty-CSS project!");
       const framework = await detectFramework(ctx);
-      compiler_saltyCompiler.logger.info(`Detected framework: ${framework.name}`);
+      logger.logger.info(`Detected framework: ${framework.name}`);
+      const plannedIntegrations = await planIntegrations(ctx);
       if (!ctx.skipInstall) {
-        await npmInstall(corePackages.core(ctx.cliVersion), framework.runtimePackage(ctx.cliVersion));
+        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 });
@@ -567,54 +653,59 @@ const registerInitCommand = (program) => {
       await writeProjectToRc(ctx.cwd, ctx.relativeProjectPath, framework);
       await ensureGitignoreSaltygen(ctx.cwd);
       await importSaltygenIntoCss(ctx.projectDir, opts.cssFile);
-      await detectAndApplyIntegrations(ctx);
+      await applyIntegrationPlans(plannedIntegrations);
       await wirePrepareScript();
-      compiler_saltyCompiler.logger.info("Running the build to generate initial CSS...");
+      logger.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 ⭐");
+      logger.logger.info("🎉 Salty CSS project initialized successfully!");
+      logger.logger.info("Next steps:");
+      logger.logger.info("1. Configure variables and templates in `salty.config.ts`");
+      logger.logger.info("2. Create a new component with `npx salty-css generate [component-name]`");
+      logger.logger.info("3. Run `npx salty-css build` to generate the CSS");
+      logger.logger.info("4. Read about the features in the documentation: https://salty-css.dev");
+      logger.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));
+      return logger.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 packageJson = await readPackageJson(packageJSONPath).catch((err) => logger.logError(err));
+  if (!packageJson) return logger.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(
+    return logger.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();
+  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.");
+    if (!saltyCssPackages) return logger.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}@${cli.version}`;
       return `${name}@${version.replace(/^@/, "")}`;
     });
+    try {
+      await confirmInstall(packagesToUpdate, yes);
+    } catch (err) {
+      return logger.logError(err instanceof Error ? err.message : String(err));
+    }
     if (legacyPeerDeps) {
-      compiler_saltyCompiler.logger.warn("Using legacy peer dependencies to update packages.");
+      logger.logger.warn("Using legacy peer dependencies to update packages.");
       await npmInstall(...packagesToUpdate, "--legacy-peer-deps");
     } else {
       await npmInstall(...packagesToUpdate);
     }
     const updatedPackages = await getSaltyCssPackages();
-    if (!updatedPackages) return compiler_saltyCompiler.logError("Something went wrong while reading the updated packages.");
+    if (!updatedPackages) return logger.logError("Something went wrong while reading the updated packages.");
     const mappedByVersions = updatedPackages.reduce((acc, [name, version2]) => {
       if (!acc[version2]) acc[version2] = [];
       acc[version2].push(name);
@@ -623,30 +714,41 @@ const registerUpdateCommand = (program) => {
     const versionsCount = Object.keys(mappedByVersions).length;
     if (versionsCount === 1) {
       const v = Object.keys(mappedByVersions)[0];
-      compiler_saltyCompiler.logger.info(`Updated to all Salty CSS packages successfully to ${v.replace(/^\^/, "")}`);
+      logger.logger.info(`Updated to all Salty CSS packages successfully to ${v.replace(/^\^/, "")}`);
     } else {
       for (const [v, names] of Object.entries(mappedByVersions)) {
-        compiler_saltyCompiler.logger.info(`Updated to ${v.replace(/^\^/, "")}: ${names.join(", ")}`);
+        logger.logger.info(`Updated to ${v.replace(/^\^/, "")}: ${names.join(", ")}`);
       }
     }
+    const project = dir ?? await getDefaultProject();
+    if (!project) {
+      logger.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);
+    logger.logger.info("Rebuilding Salty-CSS project...");
+    await new compiler_saltyCompiler.SaltyCompiler(projectDir).generateCss();
+    logger.logger.info("Rebuild complete.");
   });
 };
 const registerVersionOption = (program) => {
   program.option("-v, --version", "Show the current version of Salty-CSS.").action(async function() {
     const cli = await readThisPackageJson();
-    compiler_saltyCompiler.logger.info("CLI is running: " + cli.version);
+    logger.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));
+    const packageJson = await readPackageJson(packageJSONPath).catch((err) => logger.logError(err));
     if (!packageJson) return;
     const allDependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
     const saltyCssPackages = Object.keys(allDependencies).filter((dep) => dep === "salty-css" || dep.startsWith("@salty-css/"));
     if (!saltyCssPackages.length) {
-      return compiler_saltyCompiler.logError(
+      return logger.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
       );
     }
     for (const dep of saltyCssPackages) {
-      compiler_saltyCompiler.logger.info(`${dep}: ${allDependencies[dep]}`);
+      logger.logger.info(`${dep}: ${allDependencies[dep]}`);
     }
   });
 };