tailwind-unwind 0.3.0 → 0.4.0

package/dist/{chunk-4GXMK3NB.js → chunk-UXXIEFP4.js}

@@ -35,28 +35,28 @@ var KNOWN_COMMAND_KEYS = /* @__PURE__ */ new Set([
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function assertPositiveNumber(value, path7, errors) {
+function assertPositiveNumber(value, path9, errors) {
   if (value === void 0) {
     return;
   }
   if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
-    errors.push(`${path7} must be a positive number`);
+    errors.push(`${path9} must be a positive number`);
   }
 }
-function assertBoolean(value, path7, errors) {
+function assertBoolean(value, path9, errors) {
   if (value === void 0) {
     return;
   }
   if (typeof value !== "boolean") {
-    errors.push(`${path7} must be a boolean`);
+    errors.push(`${path9} must be a boolean`);
   }
 }
-function assertStringArray(value, path7, errors) {
+function assertStringArray(value, path9, errors) {
   if (value === void 0) {
     return;
   }
   if (!Array.isArray(value) || !value.every((item) => typeof item === "string" && item.length > 0)) {
-    errors.push(`${path7} must be an array of non-empty strings`);
+    errors.push(`${path9} must be an array of non-empty strings`);
   }
 }
 function validateCommandSection(value, section, errors) {
@@ -169,6 +169,7 @@ import fs from "fs/promises";
 import path from "path";
 import { pathToFileURL } from "url";
 var CONFIG_FILENAMES = [
+  "tailwind-unwind.config.ts",
   "tailwind-unwind.config.js",
   "tailwind-unwind.config.mjs",
   "tailwind-unwind.config.cjs",
@@ -263,7 +264,7 @@ function normalizeLoadedConfig(raw) {
 }
 function mergeCommandConfig(command, fileConfig) {
   const { analyze, generate: generate2, apply, ...root } = fileConfig;
-  const commandSection = command === "analyze" ? analyze : command === "generate" ? generate2 : apply;
+  const commandSection = command === "analyze" ? analyze : command === "generate" ? generate2 : command === "apply" ? apply : void 0;
   return {
     ...root,
     ...commandSection
@@ -323,6 +324,11 @@ async function resolveConfigFile(explicitPath, searchRoots) {
   return null;
 }
 async function importConfigModule(configPath) {
+  if (configPath.endsWith(".ts")) {
+    const { createJiti } = await import("jiti");
+    const jiti = createJiti(import.meta.url, { interopDefault: true });
+    return jiti(configPath);
+  }
   const moduleUrl = pathToFileURL(configPath).href;
   const imported = await import(moduleUrl);
   return imported;
@@ -1048,8 +1054,8 @@ var traverse = resolveTraverse(babelTraverse);
 function collectVariantRegistry(ast) {
   const registry = /* @__PURE__ */ new Map();
   traverse(ast, {
-    VariableDeclarator(path7) {
-      registerVariantDeclarator(path7.node, registry);
+    VariableDeclarator(path9) {
+      registerVariantDeclarator(path9.node, registry);
     }
   });
   return registry;
@@ -1286,8 +1292,8 @@ function resolveTraverse2(module) {
   throw new Error("Failed to load @babel/traverse");
 }
 var traverse2 = resolveTraverse2(babelTraverse2);
-function isJSXElementWithClassAttribute(path7) {
-  const opening = path7.node.openingElement;
+function isJSXElementWithClassAttribute(path9) {
+  const opening = path9.node.openingElement;
   return opening.attributes.some(
     (attr) => attr.type === "JSXAttribute" && isClassAttribute(attr)
   );
@@ -1297,11 +1303,11 @@ function collectExtractionsFromAst(ast, filePath) {
   const warnings = [];
   const variantRegistry = collectVariantRegistry(ast);
   traverse2(ast, {
-    JSXElement(path7) {
-      if (!isJSXElementWithClassAttribute(path7)) {
+    JSXElement(path9) {
+      if (!isJSXElementWithClassAttribute(path9)) {
         return;
       }
-      const opening = path7.node.openingElement;
+      const opening = path9.node.openingElement;
       for (const attr of opening.attributes) {
         if (attr.type !== "JSXAttribute") continue;
         const extraction = extractFromJSXAttribute(attr, variantRegistry);
@@ -1352,23 +1358,95 @@ var IGNORE_PATTERNS = IGNORED_DIRECTORIES.map(
   (dir) => `**/${dir}/**`
 );
 
+// src/scanner/gitChanged.ts
+import { execFile } from "child_process";
+import path2 from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".tsx", ".jsx", ".ts", ".js"]);
+function isSourceFile(filePath) {
+  const ext = path2.extname(filePath).toLowerCase();
+  return SOURCE_EXTENSIONS.has(ext);
+}
+function isIgnoredPath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  return IGNORE_PATTERNS.some((pattern) => {
+    const dir = pattern.replace("/**", "").replace("**/", "");
+    return normalized.includes(`/${dir}/`);
+  });
+}
+async function runGit(cwd, args) {
+  try {
+    const { stdout } = await execFileAsync("git", args, { cwd });
+    return stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  } catch {
+    return [];
+  }
+}
+function resolveAbsoluteFiles(files, rootPath) {
+  const absoluteRoot = path2.resolve(rootPath);
+  return [...new Set(
+    files.map((file) => path2.resolve(absoluteRoot, file)).filter((file) => file.startsWith(absoluteRoot)).filter(isSourceFile).filter((file) => !isIgnoredPath(path2.relative(absoluteRoot, file)))
+  )].sort();
+}
+async function getChangedSourceFiles(rootPath, ref = "HEAD") {
+  const cwd = path2.resolve(rootPath);
+  const unstaged = await runGit(cwd, ["diff", "--name-only", ref]);
+  const staged = await runGit(cwd, ["diff", "--cached", "--name-only", ref]);
+  const untracked = await runGit(cwd, [
+    "ls-files",
+    "--others",
+    "--exclude-standard"
+  ]);
+  return resolveAbsoluteFiles(
+    [...unstaged, ...staged, ...untracked],
+    cwd
+  );
+}
+async function findGitRoot(startPath) {
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["rev-parse", "--show-toplevel"],
+      { cwd: path2.resolve(startPath) }
+    );
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+async function isGitRepository(rootPath) {
+  return await findGitRoot(rootPath) !== null;
+}
+async function getChangedFilesInScope(scopePath, ref = "HEAD") {
+  const gitRoot = await findGitRoot(scopePath);
+  if (!gitRoot) {
+    throw new Error("Not a git repository. Remove --changed or run inside a git repo.");
+  }
+  const absoluteScope = path2.resolve(scopePath);
+  const changed = await getChangedSourceFiles(gitRoot, ref);
+  return changed.filter(
+    (file) => file === absoluteScope || file.startsWith(`${absoluteScope}${path2.sep}`)
+  );
+}
+
 // src/scanner/fileWalker.ts
 import fg from "fast-glob";
-import path2 from "path";
-var SOURCE_EXTENSIONS = ["tsx", "jsx", "ts", "js"];
+import path3 from "path";
+var SOURCE_EXTENSIONS2 = ["tsx", "jsx", "ts", "js"];
 function toAbsolutePattern(basePath, pattern) {
   const normalized = pattern.replace(/\\/g, "/");
-  if (path2.isAbsolute(normalized)) {
+  if (path3.isAbsolute(normalized)) {
     return normalized;
   }
-  return path2.join(basePath, normalized).replace(/\\/g, "/");
+  return path3.join(basePath, normalized).replace(/\\/g, "/");
 }
 function buildIncludePatterns(basePath, include) {
   if (include && include.length > 0) {
     return include.map((pattern) => toAbsolutePattern(basePath, pattern));
   }
-  return SOURCE_EXTENSIONS.map(
-    (ext) => path2.join(basePath, `**/*.${ext}`).replace(/\\/g, "/")
+  return SOURCE_EXTENSIONS2.map(
+    (ext) => path3.join(basePath, `**/*.${ext}`).replace(/\\/g, "/")
   );
 }
 function buildIgnorePatterns(exclude) {
@@ -1382,7 +1460,7 @@ function buildIgnorePatterns(exclude) {
   return [...IGNORE_PATTERNS, ...userExcludes];
 }
 async function walkSourceFiles(targetPath, options = {}) {
-  const absolutePath = path2.resolve(targetPath);
+  const absolutePath = path3.resolve(targetPath);
   const patterns = buildIncludePatterns(absolutePath, options.include);
   const ignore = buildIgnorePatterns(options.exclude);
   const files = await fg(patterns, {
@@ -1397,7 +1475,7 @@ async function walkSourceFiles(targetPath, options = {}) {
 
 // src/core/scanProject.ts
 import fs3 from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 async function pathExists2(targetPath) {
   try {
     await fs3.access(targetPath);
@@ -1407,18 +1485,23 @@ async function pathExists2(targetPath) {
   }
 }
 async function scanProject(options) {
-  const resolvedPath = path3.resolve(options.targetPath);
+  const resolvedPath = path4.resolve(options.targetPath);
   if (!await pathExists2(resolvedPath)) {
     throw new Error(`Path does not exist: ${resolvedPath}`);
   }
-  const files = await walkSourceFiles(resolvedPath, {
-    include: options.include,
-    exclude: options.exclude
-  });
+  let files;
+  if (options.changed !== void 0) {
+    const ref = typeof options.changed === "string" ? options.changed : "HEAD";
+    files = await getChangedFilesInScope(resolvedPath, ref);
+  } else {
+    files = await walkSourceFiles(resolvedPath, {
+      include: options.include,
+      exclude: options.exclude
+    });
+  }
   if (files.length === 0) {
-    throw new Error(
-      `No source files (.tsx, .jsx, .ts, .js) found in: ${resolvedPath}`
-    );
+    const hint = options.changed !== void 0 ? "No changed source files found for the current git diff." : `No source files (.tsx, .jsx, .ts, .js) found in: ${resolvedPath}`;
+    throw new Error(hint);
   }
   const occurrences = [];
   const warnings = [];
@@ -1488,8 +1571,121 @@ async function scanProject(options) {
   };
 }
 
-// src/reporters/consoleReporter.ts
+// src/commands/init.ts
+import fs4 from "fs/promises";
+import path5 from "path";
 import chalk from "chalk";
+function suggestionToName(suggestion) {
+  return suggestion.replace(/^\./, "");
+}
+function detectIncludePattern(targetPath) {
+  const normalized = targetPath.replace(/\\/g, "/");
+  if (normalized.endsWith("/src") || normalized === "src") {
+    return ["src/**/*.tsx", "src/**/*.jsx"];
+  }
+  return ["**/*.tsx", "**/*.jsx"];
+}
+function buildConfigFromScan(scanResult, targetPath, options) {
+  const extractable = scanResult.report.stats.topCombinations.filter(
+    (combo) => combo.extractable
+  );
+  const names = {};
+  for (const combo of extractable.slice(0, options.top ?? 10)) {
+    const utilities = [...combo.classes].sort().join(" ");
+    names[utilities] = suggestionToName(combo.suggestion);
+  }
+  return {
+    include: detectIncludePattern(targetPath),
+    exclude: ["**/*.test.tsx", "**/*.stories.tsx"],
+    names: Object.keys(names).length > 0 ? names : void 0,
+    analyze: {
+      minOccurrences: options.minOccurrences ?? 5,
+      top: options.top ?? 10,
+      dedupeSubsets: options.dedupeSubsets ?? true
+    },
+    generate: {
+      minOccurrences: 3,
+      prefix: options.prefix ?? "twu-",
+      output: "src/styles/components.css",
+      top: 20,
+      extractableOnly: true
+    },
+    apply: {
+      minOccurrences: 3,
+      prefix: options.prefix ?? "twu-",
+      output: "src/styles/components.css",
+      prettier: true,
+      extractableOnly: true
+    }
+  };
+}
+async function initCommand(targetPath, options = {}) {
+  const resolvedPath = path5.resolve(targetPath);
+  const outputPath = path5.resolve(
+    options.output ?? path5.join(resolvedPath, "tailwind-unwind.config.json")
+  );
+  if (!options.force && await fileExists(outputPath)) {
+    throw new Error(
+      `Config already exists: ${outputPath}. Use --force to overwrite.`
+    );
+  }
+  const scanResult = await scanProject({
+    targetPath: resolvedPath,
+    minOccurrences: options.minOccurrences ?? 5,
+    minSize: options.minSize,
+    maxSize: options.maxSize,
+    topLimit: options.top ?? 10,
+    dedupeSubsets: options.dedupeSubsets ?? true,
+    include: options.include,
+    exclude: options.exclude,
+    extractableMinOccurrences: 3
+  });
+  const config = buildConfigFromScan(scanResult, resolvedPath, options);
+  const json = `${JSON.stringify(config, null, 2)}
+`;
+  await fs4.mkdir(path5.dirname(outputPath), { recursive: true });
+  await fs4.writeFile(outputPath, json, "utf-8");
+  const extractableCount = scanResult.report.stats.topCombinations.filter(
+    (combo) => combo.extractable
+  ).length;
+  console.log("");
+  console.log(chalk.bold.green("\u2705 Config created"));
+  console.log(chalk.gray("   Output: ") + chalk.white(outputPath));
+  console.log(
+    chalk.gray("   Extractable patterns: ") + chalk.white(String(extractableCount))
+  );
+  console.log(
+    chalk.gray("   Custom names: ") + chalk.white(String(Object.keys(config.names ?? {}).length))
+  );
+  console.log("");
+  console.log(chalk.cyan("Next steps:"));
+  console.log(
+    chalk.white(
+      `  npx tailwind-unwind analyze ${targetPath} --config ${path5.basename(outputPath)}`
+    )
+  );
+  console.log(
+    chalk.white(
+      `  npx tailwind-unwind generate ${targetPath} --config ${path5.basename(outputPath)}`
+    )
+  );
+  console.log("");
+  return {
+    configPath: outputPath,
+    extractablePatterns: extractableCount
+  };
+}
+async function fileExists(targetPath) {
+  try {
+    await fs4.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/reporters/consoleReporter.ts
+import chalk2 from "chalk";
 function formatNumber(value) {
   return value.toLocaleString("en-US");
 }
@@ -1505,55 +1701,55 @@ function printConsoleReport(report, options = {}) {
   const { stats } = report;
   const topLimit = options.topLimit ?? 10;
   console.log("");
-  console.log(chalk.bold.cyan("\u{1F4CA} Tailwind Analysis Report"));
-  console.log(chalk.cyan("\u2501".repeat(41)));
-  console.log(`Files scanned: ${chalk.white(formatNumber(stats.filesScanned))}`);
+  console.log(chalk2.bold.cyan("\u{1F4CA} Tailwind Analysis Report"));
+  console.log(chalk2.cyan("\u2501".repeat(41)));
+  console.log(`Files scanned: ${chalk2.white(formatNumber(stats.filesScanned))}`);
   console.log(
-    `Components with className: ${chalk.white(formatNumber(stats.componentsWithClassName))}`
+    `Components with className: ${chalk2.white(formatNumber(stats.componentsWithClassName))}`
   );
   console.log(
-    `Unique class combinations: ${chalk.white(formatNumber(stats.uniqueCombinations))}`
+    `Unique class combinations: ${chalk2.white(formatNumber(stats.uniqueCombinations))}`
   );
   console.log("");
   if (stats.topCombinations.length === 0) {
     console.log(
-      chalk.yellow(
+      chalk2.yellow(
         "No frequent class combinations found matching the current filters."
       )
     );
   } else {
     console.log(
-      chalk.bold.green(`\u{1F3C6} Top ${Math.min(topLimit, stats.topCombinations.length)} most frequent combinations:`)
+      chalk2.bold.green(`\u{1F3C6} Top ${Math.min(topLimit, stats.topCombinations.length)} most frequent combinations:`)
     );
     console.log("");
     stats.topCombinations.forEach((combo, index) => {
       const displayClasses = normalizeClasses(combo.classes);
       console.log(
-        chalk.white(`${index + 1}. `) + chalk.yellow(`"${displayClasses}"`)
+        chalk2.white(`${index + 1}. `) + chalk2.yellow(`"${displayClasses}"`)
       );
       console.log(
-        chalk.gray(`   Occurrences: `) + chalk.white(String(combo.occurrences))
+        chalk2.gray(`   Occurrences: `) + chalk2.white(String(combo.occurrences))
       );
       console.log(
-        chalk.gray(`   Suggestion: `) + chalk.green(combo.suggestion)
+        chalk2.gray(`   Suggestion: `) + chalk2.green(combo.suggestion)
       );
       if (combo.extractable) {
         console.log(
-          chalk.gray(`   Extractable: `) + chalk.green("yes \u2014 use generate/apply")
+          chalk2.gray(`   Extractable: `) + chalk2.green("yes \u2014 use generate/apply")
         );
       } else {
         console.log(
-          chalk.gray(`   Extractable: `) + chalk.yellow("subset only \u2014 analyze hint")
+          chalk2.gray(`   Extractable: `) + chalk2.yellow("subset only \u2014 analyze hint")
         );
       }
       console.log(
-        chalk.gray(`   Found in: `) + chalk.dim(formatLocations(combo.locations))
+        chalk2.gray(`   Found in: `) + chalk2.dim(formatLocations(combo.locations))
       );
       console.log("");
     });
   }
   console.log(
-    chalk.magenta(
+    chalk2.magenta(
       `\u{1F4A1} Potential code reduction: ${stats.potentialReductionPercent}%`
     )
   );
@@ -1562,18 +1758,18 @@ function printConsoleReport(report, options = {}) {
   ).length;
   if (extractableCount > 0) {
     console.log(
-      chalk.magenta(
+      chalk2.magenta(
         `\u{1F4A1} ${extractableCount} pattern(s) ready for generate/apply`
       )
     );
   }
   console.log(
-    chalk.magenta(
+    chalk2.magenta(
       "\u{1F4A1} Generate CSS: npx tailwind-unwind generate <path> --output styles.css"
     )
   );
   console.log(
-    chalk.magenta(
+    chalk2.magenta(
       "\u{1F4A1} Apply classes: npx tailwind-unwind apply <path> --output styles.css"
     )
   );
@@ -1586,7 +1782,7 @@ function printJsonReport(report) {
 }
 
 // src/commands/analyze.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 async function analyzeCommand(targetPath, options = {}) {
   let scanResult;
   try {
@@ -1599,16 +1795,17 @@ async function analyzeCommand(targetPath, options = {}) {
       dedupeSubsets: options.dedupeSubsets,
       include: options.include,
       exclude: options.exclude,
+      changed: options.changed,
       extractableMinOccurrences: 3
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(chalk2.red(`Error: ${message}`));
+    console.error(chalk3.red(`Error: ${message}`));
     process.exit(1);
   }
   if (options.format !== "json") {
     for (const warning of scanResult.warnings) {
-      console.warn(chalk2.yellow(`\u26A0 ${warning}`));
+      console.warn(chalk3.yellow(`\u26A0 ${warning}`));
     }
   }
   const report = scanResult.report;
@@ -1620,9 +1817,36 @@ async function analyzeCommand(targetPath, options = {}) {
   return report;
 }
 
+// src/analyzer/savings.ts
+function calculateSavings(replacements) {
+  if (replacements.length === 0) {
+    return {
+      replacementCount: 0,
+      utilityTokensBefore: 0,
+      utilityTokensAfter: 0,
+      tokensSaved: 0,
+      percentReduction: 0
+    };
+  }
+  let utilityTokensBefore = 0;
+  for (const replacement of replacements) {
+    utilityTokensBefore += replacement.from.split(/\s+/).filter(Boolean).length;
+  }
+  const utilityTokensAfter = replacements.length;
+  const tokensSaved = Math.max(0, utilityTokensBefore - utilityTokensAfter);
+  const percentReduction = utilityTokensBefore === 0 ? 0 : Math.round(tokensSaved / utilityTokensBefore * 100);
+  return {
+    replacementCount: replacements.length,
+    utilityTokensBefore,
+    utilityTokensAfter,
+    tokensSaved,
+    percentReduction
+  };
+}
+
 // src/codemod/formatSource.ts
 import { createRequire } from "module";
-import path4 from "path";
+import path6 from "path";
 var require2 = createRequire(import.meta.url);
 async function loadPrettier() {
   try {
@@ -1662,7 +1886,7 @@ async function formatModifiedFiles(files, sources, cwd = process.cwd()) {
       continue;
     }
     const result = await formatSource(source, {
-      filePath: path4.resolve(cwd, file),
+      filePath: path6.resolve(cwd, file),
       cwd
     });
     if (result.formatted) {
@@ -1858,8 +2082,8 @@ function replaceClassNamesInSource(source, replacementMap, filePath) {
   }
   const variantRegistry = collectVariantRegistry(ast);
   traverse3(ast, {
-    JSXElement(path7) {
-      const opening = path7.node.openingElement;
+    JSXElement(path9) {
+      const opening = path9.node.openingElement;
       for (const attr of opening.attributes) {
         if (attr.type !== "JSXAttribute" || !isClassAttribute(attr)) {
           continue;
@@ -2042,7 +2266,7 @@ function buildComponentsFromCombinations(combinations, options) {
 }
 
 // src/core/loadAnalyzeReport.ts
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 function isAnalysisReport(value) {
   if (typeof value !== "object" || value === null) {
     return false;
@@ -2051,7 +2275,7 @@ function isAnalysisReport(value) {
   return typeof report.targetPath === "string" && typeof report.stats === "object" && Array.isArray(report.stats.topCombinations);
 }
 async function loadExtractableCombinations(reportPath, options = {}) {
-  const raw = await fs4.readFile(reportPath, "utf-8");
+  const raw = await fs5.readFile(reportPath, "utf-8");
   const parsed = JSON.parse(raw);
   if (!isAnalysisReport(parsed)) {
     throw new Error(`Invalid analyze report: ${reportPath}`);
@@ -2079,9 +2303,9 @@ function printApplyJsonReport(report) {
 }
 
 // src/commands/apply.ts
-import fs5 from "fs/promises";
-import path5 from "path";
-import chalk3 from "chalk";
+import fs6 from "fs/promises";
+import path7 from "path";
+import chalk4 from "chalk";
 async function applyCommand(targetPath, options) {
   let scanResult;
   try {
@@ -2089,16 +2313,17 @@ async function applyCommand(targetPath, options) {
       targetPath,
       include: options.include,
       exclude: options.exclude,
+      changed: options.changed,
       extractableMinOccurrences: options.minOccurrences ?? 3
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(chalk3.red(`Error: ${message}`));
+    console.error(chalk4.red(`Error: ${message}`));
     process.exit(1);
   }
   for (const warning of scanResult.warnings) {
     if (options.format !== "json") {
-      console.warn(chalk3.yellow(`\u26A0 ${warning}`));
+      console.warn(chalk4.yellow(`\u26A0 ${warning}`));
     }
   }
   let components;
@@ -2145,18 +2370,18 @@ async function applyCommand(targetPath, options) {
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(chalk3.red(`Error: ${message}`));
+    console.error(chalk4.red(`Error: ${message}`));
     process.exit(1);
   }
   if (components.length === 0) {
     console.error(
-      chalk3.yellow(
+      chalk4.yellow(
         "No repeated className sets found. Try lowering --min-occurrences."
       )
     );
     process.exit(1);
   }
-  const outputPath = path5.resolve(options.output);
+  const outputPath = path7.resolve(options.output);
   let filesModified = 0;
   let replacementsTotal = 0;
   const allReplacements = [];
@@ -2164,7 +2389,7 @@ async function applyCommand(targetPath, options) {
   const modifiedSources = /* @__PURE__ */ new Map();
   const modifiedFiles = [];
   for (const file of scanResult.files) {
-    const original = await fs5.readFile(file, "utf-8");
+    const original = await fs6.readFile(file, "utf-8");
     const result2 = replaceClassNamesInSource(
       original,
       replacementMap,
@@ -2192,12 +2417,13 @@ async function applyCommand(targetPath, options) {
     for (const file of modifiedFiles) {
       const source = modifiedSources.get(file);
       if (source) {
-        await fs5.writeFile(file, source, "utf-8");
+        await fs6.writeFile(file, source, "utf-8");
       }
     }
-    await fs5.mkdir(path5.dirname(outputPath), { recursive: true });
-    await fs5.writeFile(outputPath, css, "utf-8");
+    await fs6.mkdir(path7.dirname(outputPath), { recursive: true });
+    await fs6.writeFile(outputPath, css, "utf-8");
   }
+  const savings = calculateSavings(allReplacements);
   const result = {
     filesModified,
     replacementsTotal,
@@ -2206,7 +2432,8 @@ async function applyCommand(targetPath, options) {
     components,
     replacements: allReplacements,
     skipped: allSkipped,
-    prettierFormatted
+    prettierFormatted,
+    savings
   };
   if (options.format === "json") {
     printApplyJsonReport({
@@ -2218,58 +2445,75 @@ async function applyCommand(targetPath, options) {
       componentsGenerated: components.length,
       components,
       replacements: allReplacements,
-      skipped: allSkipped
+      skipped: allSkipped,
+      savings
     });
     return result;
   }
   console.log("");
   if (options.dryRun) {
-    console.log(chalk3.bold.yellow("\u{1F50D} Dry run \u2014 no files were modified"));
+    console.log(chalk4.bold.yellow("\u{1F50D} Dry run \u2014 no files were modified"));
   } else {
-    console.log(chalk3.bold.green("\u2705 Classes applied successfully"));
+    console.log(chalk4.bold.green("\u2705 Classes applied successfully"));
   }
-  console.log(chalk3.gray(`   CSS output: `) + chalk3.white(outputPath));
+  console.log(chalk4.gray(`   CSS output: `) + chalk4.white(outputPath));
   console.log(
-    chalk3.gray(`   Component classes: `) + chalk3.white(String(components.length))
+    chalk4.gray(`   Component classes: `) + chalk4.white(String(components.length))
   );
   console.log(
-    chalk3.gray(`   Files modified: `) + chalk3.white(String(filesModified))
+    chalk4.gray(`   Files modified: `) + chalk4.white(String(filesModified))
   );
   console.log(
-    chalk3.gray(`   Replacements: `) + chalk3.white(String(replacementsTotal))
+    chalk4.gray(`   Replacements: `) + chalk4.white(String(replacementsTotal))
   );
   if (prettierFormatted.length > 0) {
     console.log(
-      chalk3.gray(`   Prettier formatted: `) + chalk3.white(String(prettierFormatted.length))
+      chalk4.gray(`   Prettier formatted: `) + chalk4.white(String(prettierFormatted.length))
+    );
+  }
+  if (savings.replacementCount > 0) {
+    console.log("");
+    console.log(chalk4.bold("Savings:"));
+    console.log(
+      chalk4.gray("   Utility tokens before: ") + chalk4.white(String(savings.utilityTokensBefore))
+    );
+    console.log(
+      chalk4.gray("   Utility tokens after: ") + chalk4.white(String(savings.utilityTokensAfter))
+    );
+    console.log(
+      chalk4.gray("   Tokens saved: ") + chalk4.green(String(savings.tokensSaved))
+    );
+    console.log(
+      chalk4.gray("   Reduction: ") + chalk4.green(`${savings.percentReduction}%`)
     );
   }
   if (allReplacements.length > 0) {
     console.log("");
-    console.log(chalk3.bold("Replacements:"));
+    console.log(chalk4.bold("Replacements:"));
     for (const item of allReplacements) {
       const line = item.line ? `:${item.line}` : "";
-      const partialTag = item.partial ? chalk3.dim(" (partial)") : "";
+      const partialTag = item.partial ? chalk4.dim(" (partial)") : "";
       console.log(
-        chalk3.gray(`  ${item.filePath}${line}`) + chalk3.white(` "${item.from}" `) + chalk3.cyan("\u2192") + chalk3.green(` "${item.to}"`) + partialTag
+        chalk4.gray(`  ${item.filePath}${line}`) + chalk4.white(` "${item.from}" `) + chalk4.cyan("\u2192") + chalk4.green(` "${item.to}"`) + partialTag
       );
     }
   }
   if (allSkipped.length > 0) {
     console.log("");
-    console.log(chalk3.bold.yellow(`Skipped (${allSkipped.length}):`));
+    console.log(chalk4.bold.yellow(`Skipped (${allSkipped.length}):`));
     for (const item of allSkipped) {
       const line = item.line ? `:${item.line}` : "";
       const classes = item.classes.join(" ");
       console.log(
-        chalk3.gray(`  ${item.filePath}${line}`) + chalk3.yellow(` [${item.reason}]`) + chalk3.dim(` "${classes}"`)
+        chalk4.gray(`  ${item.filePath}${line}`) + chalk4.yellow(` [${item.reason}]`) + chalk4.dim(` "${classes}"`)
       );
     }
   }
   console.log("");
   if (!options.dryRun) {
     console.log(
-      chalk3.cyan(
-        `Import ${path5.basename(outputPath)} in your global CSS if you haven't already.`
+      chalk4.cyan(
+        `Import ${path7.basename(outputPath)} in your global CSS if you haven't already.`
       )
     );
     console.log("");
@@ -2278,9 +2522,9 @@ async function applyCommand(targetPath, options) {
 }
 
 // src/commands/generate.ts
-import fs6 from "fs/promises";
-import path6 from "path";
-import chalk4 from "chalk";
+import fs7 from "fs/promises";
+import path8 from "path";
+import chalk5 from "chalk";
 async function generateCommand(targetPath, options) {
   let scanResult = null;
   let components;
@@ -2302,6 +2546,7 @@ async function generateCommand(targetPath, options) {
         targetPath,
         include: options.include,
         exclude: options.exclude,
+        changed: options.changed,
         extractableMinOccurrences: options.minOccurrences ?? 3
       });
       if (options.extractableOnly) {
@@ -2331,19 +2576,19 @@ async function generateCommand(targetPath, options) {
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(chalk4.red(`Error: ${message}`));
+    console.error(chalk5.red(`Error: ${message}`));
     process.exit(1);
   }
   if (scanResult) {
     for (const warning of scanResult.warnings) {
       if (options.format !== "json") {
-        console.warn(chalk4.yellow(`\u26A0 ${warning}`));
+        console.warn(chalk5.yellow(`\u26A0 ${warning}`));
       }
     }
   }
-  const outputPath = path6.resolve(options.output);
-  await fs6.mkdir(path6.dirname(outputPath), { recursive: true });
-  await fs6.writeFile(outputPath, css, "utf-8");
+  const outputPath = path8.resolve(options.output);
+  await fs7.mkdir(path8.dirname(outputPath), { recursive: true });
+  await fs7.writeFile(outputPath, css, "utf-8");
   const result = {
     outputPath,
     componentsGenerated: components.length,
@@ -2361,28 +2606,28 @@ async function generateCommand(targetPath, options) {
     return result;
   }
   console.log("");
-  console.log(chalk4.bold.green("\u2705 CSS generated successfully"));
-  console.log(chalk4.gray(`   Output: `) + chalk4.white(outputPath));
+  console.log(chalk5.bold.green("\u2705 CSS generated successfully"));
+  console.log(chalk5.gray(`   Output: `) + chalk5.white(outputPath));
   console.log(
-    chalk4.gray(`   Components: `) + chalk4.white(String(components.length))
+    chalk5.gray(`   Components: `) + chalk5.white(String(components.length))
   );
   if (components.length > 0) {
     console.log("");
-    console.log(chalk4.bold("Generated classes:"));
+    console.log(chalk5.bold("Generated classes:"));
     for (const component of components) {
       console.log(
-        chalk4.green(`  .${component.className}`) + chalk4.gray(` \u2014 ${component.occurrences} occurrences, `) + chalk4.dim(component.classes.join(" "))
+        chalk5.green(`  .${component.className}`) + chalk5.gray(` \u2014 ${component.occurrences} occurrences, `) + chalk5.dim(component.classes.join(" "))
       );
     }
     console.log("");
     console.log(
-      chalk4.cyan(
+      chalk5.cyan(
         "Run apply to replace className strings: npx tailwind-unwind apply <path> --output styles.css"
       )
     );
   } else {
     console.log(
-      chalk4.yellow(
+      chalk5.yellow(
         "\nNo repeated className sets matched the filters. Try lowering --min-occurrences."
       )
     );
@@ -2417,11 +2662,16 @@ export {
   parseFile,
   IGNORED_DIRECTORIES,
   IGNORE_PATTERNS,
+  getChangedSourceFiles,
+  isGitRepository,
+  getChangedFilesInScope,
   walkSourceFiles,
   scanProject,
+  initCommand,
   printConsoleReport,
   printJsonReport,
   analyzeCommand,
+  calculateSavings,
   formatSource,
   formatModifiedFiles,
   replaceClassNamesInSource,
@@ -2438,4 +2688,4 @@ export {
   applyCommand,
   generateCommand
 };
-//# sourceMappingURL=chunk-4GXMK3NB.js.map
+//# sourceMappingURL=chunk-UXXIEFP4.js.map