tailwind-canonical 0.6.0 → 0.7.1

package/dist/cli/cli.js

@@ -1,21 +1,20 @@
-import { existsSync, watch as fsWatch, readFileSync, writeFileSync, } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { analyzeFile } from '../core/analyzer.js';
 import { toClassStringOpts } from '../core/class-strings.js';
-import { CONFIG_FILENAMES, loadConfig } from '../core/config.js';
+import { CONFIG_FILENAMES, loadConfig, resolveInitFilename, } from '../core/config.js';
 import { analyzeConsistencyFiles, toConsistencyOptions, } from '../core/consistency.js';
-import { dedupeContent, dedupeFile } from '../core/deduplicator.js';
-import { fixContent, fixFile } from '../core/fixer.js';
-import { mergeContent, mergeFile } from '../core/merger.js';
+import { dedupeContent } from '../core/deduplicator.js';
+import { fixContent } from '../core/fixer.js';
+import { mergeContent } from '../core/merger.js';
 import { resolveTargets } from '../core/scanner.js';
-import { sortContent, sortFile } from '../core/sorter.js';
+import { sortContent } from '../core/sorter.js';
 import { analyzeTyposFile } from '../core/typos.js';
-const SARIF_SCHEMA = 'https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json';
+import { errMsg, pluralize, timestamp } from './format.js';
+import { analyzeSarifDocument, findingsSarifDocument, logAnalyzeText, logFindings, logTransformCounts, logTyposText, logWatchFindings, sarifDocument, typoSarifDocument, writeJson, } from './reporters.js';
+import { startWatch } from './watch.js';
 const USAGE = 'Usage: tailwind-canonical [--fix] [--merge] [--dedup] [--sort] [--check] [--analyze] [--typos] [--watch] [--reporter json|sarif] <dir|file> [dir|file...]\n       tailwind-canonical init';
-const INIT_CONFIG_CONTENT = [
-    "import type { Config } from 'tailwind-canonical'",
-    '',
-    'export default {',
+const INIT_CONFIG_BODY = [
     '  // Run `tailwind-canonical` with no flags using these defaults:',
     "  // defaultCommand: { fix: true, dedup: true, sort: true, typos: true, targets: ['./src'] },",
     '  // px → token additions/overrides:',
@@ -23,13 +22,26 @@ const INIT_CONFIG_CONTENT = [
     "  // customSpacingTokens: { 14: '3.5' },",
     '  // Never suggest replacements for classes matching:',
     '  // ignorePatterns: [/^font-/],',
+];
+const INIT_CONFIG_TS = [
+    "import type { Config } from 'tailwind-canonical'",
+    '',
+    'export default {',
+    ...INIT_CONFIG_BODY,
     '} satisfies Config',
     '',
 ].join('\n');
+const INIT_CONFIG_JS = [
+    "/** @type {import('tailwind-canonical').Config} */",
+    'export default {',
+    ...INIT_CONFIG_BODY,
+    '}',
+    '',
+].join('\n');
 const HELP_TEXT = [
     USAGE,
     '',
-    '  init               Create a tailwind-canonical.config.ts scaffold in the current directory',
+    '  init               Create a tailwind-canonical config scaffold in the current directory',
     '  --fix              Auto-replace arbitrary values with canonical Tailwind classes',
     '  --dedup            Remove redundant classes and collapse shorthands',
     '  --merge            Resolve conflicting classes via tailwind-merge',
@@ -51,49 +63,6 @@ const defaultSink = {
     write: (s) => process.stdout.write(s),
 };
 const KNOWN_CLASS_FUNCTIONS = ['cn', 'clsx', 'cva'];
-const DEFAULT_ANALYZE_TEXT_OPTIONS = {
-    maxScaleGroups: 8,
-    maxScaleValues: 5,
-    maxRareValues: 12,
-    maxPatterns: 10,
-};
-function sarifDocument(rules, results) {
-    return {
-        $schema: SARIF_SCHEMA,
-        version: '2.1.0',
-        runs: [
-            {
-                tool: {
-                    driver: {
-                        name: 'tailwind-canonical',
-                        informationUri: 'https://github.com/peak-lab/tailwind-canonical',
-                        rules,
-                    },
-                },
-                results,
-            },
-        ],
-    };
-}
-function fileLocations(files) {
-    return files.map((uri) => ({
-        physicalLocation: {
-            artifactLocation: { uri },
-            region: { startLine: 1, startColumn: 1 },
-        },
-    }));
-}
-function errMsg(e) {
-    return e instanceof Error ? e.message : String(e);
-}
-function pluralize(n, word) {
-    return `${n} ${word}${n !== 1 ? 's' : ''}`;
-}
-function timestamp() {
-    const d = new Date();
-    const pad = (n) => n.toString().padStart(2, '0');
-    return `[${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}]`;
-}
 const REPORTERS = ['text', 'json', 'sarif'];
 const MODE_FLAGS = [
     '--fix',
@@ -185,35 +154,26 @@ export function parseArgs(argv) {
         hasExplicitCheck: argv.includes('--check'),
     };
 }
+/** Explicit CLI flags win; otherwise `defaultCommand` fills the gap. */
+function fallback(explicit, flag, configured) {
+    return explicit ? flag : (configured ?? flag);
+}
 function applyDefaultCommand(flags, config) {
     const defaults = config.defaultCommand;
     if (!defaults)
         return flags;
+    const mode = flags.hasExplicitMode;
     return {
         ...flags,
-        fix: flags.hasExplicitMode ? flags.fix : (defaults.fix ?? flags.fix),
-        merge: flags.hasExplicitMode
-            ? flags.merge
-            : (defaults.merge ?? flags.merge),
-        dedup: flags.hasExplicitMode
-            ? flags.dedup
-            : (defaults.dedup ?? flags.dedup),
-        sort: flags.hasExplicitMode ? flags.sort : (defaults.sort ?? flags.sort),
-        analyze: flags.hasExplicitMode
-            ? flags.analyze
-            : (defaults.analyze ?? flags.analyze),
-        typos: flags.hasExplicitMode
-            ? flags.typos
-            : (defaults.typos ?? flags.typos),
-        watch: flags.hasExplicitWatch
-            ? flags.watch
-            : (defaults.watch ?? flags.watch),
-        check: flags.hasExplicitCheck
-            ? flags.check
-            : (defaults.check ?? flags.check),
-        reporter: flags.hasExplicitReporter
-            ? flags.reporter
-            : (defaults.reporter ?? flags.reporter),
+        fix: fallback(mode, flags.fix, defaults.fix),
+        merge: fallback(mode, flags.merge, defaults.merge),
+        dedup: fallback(mode, flags.dedup, defaults.dedup),
+        sort: fallback(mode, flags.sort, defaults.sort),
+        analyze: fallback(mode, flags.analyze, defaults.analyze),
+        typos: fallback(mode, flags.typos, defaults.typos),
+        watch: fallback(flags.hasExplicitWatch, flags.watch, defaults.watch),
+        check: fallback(flags.hasExplicitCheck, flags.check, defaults.check),
+        reporter: fallback(flags.hasExplicitReporter, flags.reporter, defaults.reporter),
         targets: flags.targets.length > 0 ? flags.targets : (defaults.targets ?? []),
     };
 }
@@ -274,102 +234,104 @@ function collectTypos(files, config, sink) {
     }
     return { findings, hadError };
 }
-function logTyposText(findings, sink) {
-    for (const f of findings) {
-        sink.log(`  ${f.file}:${f.line}:${f.col}  ${f.original} → ${f.suggestion} [typo]`);
+function readVersion() {
+    const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+    return pkg.version;
+}
+function findProjectRoot(cwd) {
+    let dir = resolve(cwd);
+    while (true) {
+        if (existsSync(join(dir, '.git')))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return resolve(cwd);
+        dir = parent;
     }
-    if (findings.length === 0) {
-        sink.log('✓ No likely typos found');
+}
+function sarifContext(cwd) {
+    let version;
+    try {
+        version = readVersion();
     }
-    else {
-        sink.log(`\n✖ Found ${pluralize(findings.length, 'likely typo')}`);
+    catch {
+        version = undefined;
     }
+    return { root: findProjectRoot(cwd), version };
 }
-function typoSarifDocument(findings) {
-    return sarifDocument([
-        {
-            id: 'color-typo',
-            name: 'ColorTypo',
-            shortDescription: {
-                text: 'Class color name is a likely typo of a Tailwind color',
-            },
-        },
-    ], findings.map((f) => ({
-        ruleId: 'color-typo',
-        message: { text: `${f.original} → ${f.suggestion}` },
-        locations: [
-            {
-                physicalLocation: {
-                    artifactLocation: { uri: f.file },
-                    region: { startLine: f.line, startColumn: f.col },
-                },
-            },
-        ],
-    })));
-}
-function runTypos(files, config, reporter, sink) {
+function runTypos(files, config, reporter, sink, sarif) {
     const { findings, hadError } = collectTypos(files, config, sink);
     if (reporter === 'json') {
         const report = {
             total: findings.length,
             typos: findings,
         };
-        sink.write(`${JSON.stringify(report, null, 2)}\n`);
-        return { exitCode: findings.length > 0 || hadError ? 1 : 0 };
+        writeJson(sink, report);
     }
-    if (reporter === 'sarif') {
-        sink.write(`${JSON.stringify(typoSarifDocument(findings), null, 2)}\n`);
-        return { exitCode: findings.length > 0 || hadError ? 1 : 0 };
+    else if (reporter === 'sarif') {
+        writeJson(sink, typoSarifDocument(findings, sarif));
     }
-    logTyposText(findings, sink);
-    return { exitCode: findings.length > 0 || hadError ? 1 : 0 };
-}
-async function processFile(file, flags, config) {
-    const opts = toClassStringOpts(config);
-    const counts = { fixed: 0, deduped: 0, merged: 0, sorted: 0 };
-    if (flags.fix)
-        counts.fixed = fixFile(file, config);
-    if (flags.dedup)
-        counts.deduped = dedupeFile(file, opts);
-    if (flags.merge)
-        counts.merged = await mergeFile(file, opts);
-    if (flags.sort)
-        counts.sorted = sortFile(file, opts, config.sortOrder);
-    return counts;
+    else {
+        logTyposText(findings, sink);
+    }
+    return exitWith(findings.length > 0 || hadError);
 }
-async function checkFile(file, flags, config, twMerge) {
+function applyTransforms(content, flags, config, twMerge) {
     const opts = toClassStringOpts(config);
-    const counts = { fixed: 0, deduped: 0, merged: 0, sorted: 0 };
-    let content = readFileSync(file, 'utf8');
+    const counts = emptyCounts();
+    let result = content;
     if (flags.fix) {
-        const { result, count } = fixContent(content, config);
-        counts.fixed = count;
-        content = result;
+        const fixed = fixContent(result, config);
+        counts.fixed = fixed.count;
+        result = fixed.result;
     }
     if (flags.dedup) {
-        const { result, count } = dedupeContent(content, opts);
-        counts.deduped = count;
-        content = result;
+        const deduped = dedupeContent(result, opts);
+        counts.deduped = deduped.count;
+        result = deduped.result;
     }
-    if (flags.merge && twMerge) {
-        const { result, count } = mergeContent(content, twMerge, opts);
-        counts.merged = count;
-        content = result;
+    if (flags.merge) {
+        if (!twMerge) {
+            throw new Error('--merge requires the optional peer dependency "tailwind-merge". Install it with: pnpm add -D tailwind-merge');
+        }
+        const merged = mergeContent(result, twMerge, opts);
+        counts.merged = merged.count;
+        result = merged.result;
     }
     if (flags.sort) {
-        const { result, count } = sortContent(content, opts, config.sortOrder);
-        counts.sorted = count;
-        content = result;
+        const sorted = sortContent(result, opts, config.sortOrder);
+        counts.sorted = sorted.count;
+        result = sorted.result;
     }
+    return { counts, result };
+}
+function processFile(file, flags, config, twMerge) {
+    const content = readFileSync(file, 'utf8');
+    const { counts, result } = applyTransforms(content, flags, config, twMerge);
+    // Counts, not text equality: replaceClassStrings also normalizes attribute
+    // spacing, which no transform counts. Writing on any textual difference
+    // would rewrite files that --check truthfully reports as clean.
+    if (totalOf(counts) > 0)
+        writeFileSync(file, result, 'utf8');
     return counts;
 }
 function totalOf(c) {
     return c.fixed + c.deduped + c.merged + c.sorted;
 }
-function scaleClass(property, value) {
-    return value.startsWith('-')
-        ? `-${property}-${value.slice(1)}`
-        : `${property}-${value}`;
+function emptyCounts() {
+    return { fixed: 0, deduped: 0, merged: 0, sorted: 0 };
+}
+function addCounts(target, source) {
+    target.fixed += source.fixed;
+    target.deduped += source.deduped;
+    target.merged += source.merged;
+    target.sorted += source.sorted;
+}
+function isTransforming(flags) {
+    return flags.fix || flags.dedup || flags.merge || flags.sort;
+}
+function exitWith(failed) {
+    return { exitCode: failed ? 1 : 0 };
 }
 function findUnconfiguredClassFunctions(files, config) {
     const configured = new Set(config.functionNames ?? []);
@@ -392,93 +354,7 @@ function findUnconfiguredClassFunctions(files, config) {
     }
     return [...found].sort();
 }
-function compactPath(file) {
-    const normalized = file.replace(/\\/g, '/');
-    const parts = normalized.split('/');
-    if (parts.length <= 4)
-        return normalized;
-    return `.../${parts.slice(-4).join('/')}`;
-}
-function withMore(values, limit, format) {
-    const shown = values.slice(0, limit).map(format);
-    const remaining = values.length - shown.length;
-    if (remaining > 0)
-        shown.push(`+${remaining} more`);
-    return shown.join(', ');
-}
-function scaleValueSummary(property, value) {
-    return `${scaleClass(property, value.value)} (${pluralize(value.count, 'use')}, ${pluralize(value.files.length, 'file')})`;
-}
-function scaleTotalUses(scale) {
-    return scale.values.reduce((sum, value) => sum + value.count, 0);
-}
-function logAnalyzeText(report, issueCount, config, sink) {
-    const textOptions = {
-        maxScaleGroups: config.analyze?.maxScaleGroups ??
-            DEFAULT_ANALYZE_TEXT_OPTIONS.maxScaleGroups,
-        maxScaleValues: config.analyze?.maxScaleValues ??
-            DEFAULT_ANALYZE_TEXT_OPTIONS.maxScaleValues,
-        maxRareValues: config.analyze?.maxRareValues ??
-            DEFAULT_ANALYZE_TEXT_OPTIONS.maxRareValues,
-        maxPatterns: config.analyze?.maxPatterns ?? DEFAULT_ANALYZE_TEXT_OPTIONS.maxPatterns,
-    };
-    sink.log('tailwind-canonical analyze');
-    sink.log(`Files analyzed: ${report.filesAnalyzed}`);
-    sink.log(`Issue groups: ${issueCount} (${pluralize(report.colorVariants.length, 'color')}, ${pluralize(report.scaleInconsistencies.length, 'scale')}, ${pluralize(report.combinations.length, 'pattern')})`);
-    if (report.rareScaleValues.length > 0) {
-        sink.log(`Rare values: ${report.rareScaleValues.length}`);
-    }
-    if (issueCount === 0) {
-        sink.log('\nNo cross-file inconsistencies found');
-        return;
-    }
-    if (report.colorVariants.length > 0) {
-        sink.log('\nColor variants');
-        for (const group of report.colorVariants) {
-            const tokens = group.variants
-                .map((v) => `${group.property}-${v.token} x${v.count}`)
-                .join(', ');
-            sink.log(`  - ${group.property}/${group.family}: ${tokens}`);
-        }
-    }
-    if (report.scaleInconsistencies.length > 0) {
-        sink.log('\nScale inconsistency groups');
-        const scales = [...report.scaleInconsistencies].sort((a, b) => scaleTotalUses(b) - scaleTotalUses(a) ||
-            a.property.localeCompare(b.property));
-        for (const scale of scales.slice(0, textOptions.maxScaleGroups)) {
-            const totalUses = scaleTotalUses(scale);
-            const files = new Set(scale.values.flatMap((value) => value.files));
-            sink.log(`  - ${scale.property}: ${scale.values.length} values, ${totalUses} uses, ${pluralize(files.size, 'file')}`);
-            sink.log(`    Top: ${withMore(scale.values, textOptions.maxScaleValues, (value) => scaleValueSummary(scale.property, value))}`);
-        }
-        const remaining = scales.length - textOptions.maxScaleGroups;
-        if (remaining > 0)
-            sink.log(`  - +${remaining} more scale groups`);
-    }
-    if (report.rareScaleValues.length > 0) {
-        sink.log('\nRare scale values');
-        for (const rare of report.rareScaleValues.slice(0, textOptions.maxRareValues)) {
-            const example = rare.files[0]
-                ? `; e.g. ${compactPath(rare.files[0])}`
-                : '';
-            sink.log(`  - ${rare.className}: ${pluralize(rare.count, 'use')} in ${pluralize(rare.files.length, 'file')} (${rare.propertyCount} ${rare.property} uses total)${example}`);
-        }
-        const remaining = report.rareScaleValues.length - textOptions.maxRareValues;
-        if (remaining > 0)
-            sink.log(`  - +${remaining} more rare values`);
-    }
-    if (report.combinations.length > 0) {
-        sink.log('\nRepeated patterns');
-        for (const combo of report.combinations.slice(0, textOptions.maxPatterns)) {
-            sink.log(`  - Pattern: "${combo.classes.join(' ')}" repeated in ${pluralize(combo.files.length, 'file')}`);
-        }
-        const remaining = report.combinations.length - textOptions.maxPatterns;
-        if (remaining > 0)
-            sink.log(`  - +${remaining} more repeated patterns`);
-    }
-    sink.log(`\nFound ${pluralize(issueCount, 'consistency issue')} across ${pluralize(report.filesAnalyzed, 'file')}`);
-}
-function runAnalyze(files, config, reporter, sink) {
+function runAnalyze(files, config, reporter, sink, sarif) {
     let hadError = false;
     const options = toConsistencyOptions(config);
     const report = analyzeConsistencyFiles(files, config, options, (file, err) => {
@@ -496,135 +372,15 @@ function runAnalyze(files, config, reporter, sink) {
         sink.error(`Warning: detected ${calls} calls but functionNames does not include them; --analyze may miss class strings.`);
     }
     if (reporter === 'json') {
-        sink.write(`${JSON.stringify(report, null, 2)}\n`);
-        return { exitCode: issueCount > 0 || hadError ? 1 : 0 };
+        writeJson(sink, report);
     }
-    if (reporter === 'sarif') {
-        const results = [];
-        for (const group of report.colorVariants) {
-            const tokens = group.variants.map((v) => v.token).join(', ');
-            const files = [...new Set(group.variants.flatMap((v) => v.files))];
-            results.push({
-                ruleId: 'color-variant-inconsistency',
-                message: {
-                    text: `${group.variants.length} ${group.family} color variants for ${group.property}: ${tokens}`,
-                },
-                locations: fileLocations(files),
-            });
-        }
-        for (const scale of report.scaleInconsistencies) {
-            const values = scale.values
-                .map((v) => scaleClass(scale.property, v.value))
-                .join(' vs ');
-            const files = [...new Set(scale.values.flatMap((v) => v.files))];
-            results.push({
-                ruleId: 'scale-inconsistency',
-                message: { text: `${scale.property} inconsistency: ${values}` },
-                locations: fileLocations(files),
-            });
-        }
-        for (const rare of report.rareScaleValues) {
-            results.push({
-                ruleId: 'rare-scale-value',
-                message: {
-                    text: `${rare.className} is rare for ${rare.property}: ${rare.count} occurrence(s) in ${rare.files.length} file(s), within ${rare.propertyCount} ${rare.property} uses`,
-                },
-                locations: fileLocations(rare.files),
-            });
-        }
-        for (const combo of report.combinations) {
-            results.push({
-                ruleId: 'repeated-combination',
-                message: {
-                    text: `Repeated class combination: ${combo.classes.join(' ')}`,
-                },
-                locations: fileLocations(combo.files),
-            });
-        }
-        const sarifOutput = sarifDocument([
-            {
-                id: 'color-variant-inconsistency',
-                name: 'ColorVariantInconsistency',
-                shortDescription: {
-                    text: 'Multiple color variants of the same family used for one property',
-                },
-            },
-            {
-                id: 'scale-inconsistency',
-                name: 'ScaleInconsistency',
-                shortDescription: {
-                    text: 'Inconsistent scale values used for the same property',
-                },
-            },
-            {
-                id: 'rare-scale-value',
-                name: 'RareScaleValue',
-                shortDescription: {
-                    text: 'A scale value appears rarely within an otherwise common property',
-                },
-            },
-            {
-                id: 'repeated-combination',
-                name: 'RepeatedCombination',
-                shortDescription: {
-                    text: 'Identical class combination repeated across files',
-                },
-            },
-        ], results);
-        sink.write(`${JSON.stringify(sarifOutput, null, 2)}\n`);
-        return { exitCode: issueCount > 0 || hadError ? 1 : 0 };
-    }
-    logAnalyzeText(report, issueCount, config, sink);
-    return { exitCode: issueCount > 0 || hadError ? 1 : 0 };
-}
-function startWatch(files, flags, config, sink) {
-    const transforming = flags.fix || flags.dedup || flags.merge || flags.sort;
-    const fileSet = new Set(files);
-    const inFlight = new Set();
-    const timers = new Map();
-    const dirs = new Set(files.map((f) => dirname(f)));
-    sink.log(`Watching ${pluralize(files.length, 'file')}... (Ctrl+C to stop)`);
-    for (const dir of dirs) {
-        fsWatch(dir, { recursive: true }, (_, filename) => {
-            if (!filename)
-                return;
-            const full = resolve(dir, filename);
-            if (!fileSet.has(full) || inFlight.has(full))
-                return;
-            clearTimeout(timers.get(full));
-            timers.set(full, setTimeout(() => {
-                if (transforming) {
-                    inFlight.add(full);
-                    processFile(full, flags, config)
-                        .then((counts) => {
-                        const total = totalOf(counts);
-                        if (total > 0) {
-                            sink.log(`${timestamp()} ${full} — ${pluralize(total, 'change')} applied`);
-                        }
-                    })
-                        .catch((err) => {
-                        sink.error(`${timestamp()} ${full} — error: ${err instanceof Error ? err.message : String(err)}`);
-                    })
-                        .finally(() => inFlight.delete(full));
-                }
-                else {
-                    const findings = analyzeFile(full, config);
-                    if (findings.length > 0) {
-                        sink.log(`${timestamp()} ${full} — ${pluralize(findings.length, 'finding')}`);
-                        for (const f of findings) {
-                            const tag = f.suggestion.isCustomToken ? ' [custom token]' : '';
-                            sink.log(`  ${f.line}:${f.col}  ${f.suggestion.original} → ${f.suggestion.canonical}${tag}`);
-                        }
-                    }
-                }
-            }, 50));
-        });
+    else if (reporter === 'sarif') {
+        writeJson(sink, analyzeSarifDocument(report, sarif));
     }
-    process.once('SIGINT', () => {
-        sink.log('\nWatcher stopped.');
-        process.exit(0);
-    });
-    return { exitCode: 0, watching: true };
+    else {
+        logAnalyzeText(report, issueCount, config, sink);
+    }
+    return exitWith(issueCount > 0 || hadError);
 }
 function runInit(cwd, sink) {
     const existing = CONFIG_FILENAMES.find((name) => existsSync(join(cwd, name)));
@@ -632,8 +388,9 @@ function runInit(cwd, sink) {
         sink.error(`${existing} already exists`);
         return { exitCode: 1 };
     }
-    const filename = CONFIG_FILENAMES[0];
-    writeFileSync(join(cwd, filename), INIT_CONFIG_CONTENT, 'utf8');
+    const filename = resolveInitFilename(cwd);
+    const content = /\.m?ts$/.test(filename) ? INIT_CONFIG_TS : INIT_CONFIG_JS;
+    writeFileSync(join(cwd, filename), content, 'utf8');
     sink.log(`Created ${filename}`);
     sink.log('Uncomment defaultCommand to set your CLI defaults.');
     sink.log('Then run `npx tailwind-canonical` to lint your project.');
@@ -647,8 +404,7 @@ export async function run(argv, cwd, sink = defaultSink) {
     }
     if (flags.version) {
         try {
-            const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
-            sink.log(pkg.version);
+            sink.log(readVersion());
             return { exitCode: 0 };
         }
         catch (err) {
@@ -680,7 +436,7 @@ export async function run(argv, cwd, sink = defaultSink) {
         config = await loadConfig(cwd);
     }
     catch (err) {
-        sink.error(`tailwind-canonical: ${err instanceof Error ? err.message : String(err)}`);
+        sink.error(`tailwind-canonical: ${errMsg(err)}`);
         return { exitCode: 1 };
     }
     flags = applyDefaultCommand(flags, config);
@@ -688,12 +444,7 @@ export async function run(argv, cwd, sink = defaultSink) {
         sink.error(USAGE);
         return { exitCode: 1 };
     }
-    if (flags.check &&
-        !flags.analyze &&
-        !flags.fix &&
-        !flags.dedup &&
-        !flags.merge &&
-        !flags.sort) {
+    if (flags.check && !flags.analyze && !isTransforming(flags)) {
         sink.error('--check requires at least one of --fix, --dedup, --merge, --sort');
         return { exitCode: 1 };
     }
@@ -716,125 +467,126 @@ export async function run(argv, cwd, sink = defaultSink) {
         sink.error(`No files matched: ${flags.targets.join(' ')}`);
         return { exitCode: 1 };
     }
-    if (flags.analyze)
-        return runAnalyze(files, config, flags.reporter, sink);
-    const transforming = flags.fix || flags.dedup || flags.merge || flags.sort;
+    const sarif = sarifContext(cwd);
+    if (flags.analyze) {
+        return runAnalyze(files, config, flags.reporter, sink, sarif);
+    }
+    const transforming = isTransforming(flags);
     if (flags.typos && !transforming) {
-        return runTypos(files, config, flags.reporter, sink);
+        return runTypos(files, config, flags.reporter, sink, sarif);
+    }
+    if (flags.watch && !flags.typos && !flags.check) {
+        return startWatch({
+            files,
+            sink,
+            processFile: (file) => transforming
+                ? watchTransform(file, flags, config, sink, twMerge)
+                : logWatchFindings(file, analyzeFile(file, config), timestamp(), sink),
+        });
+    }
+    return transforming
+        ? runTransforms(files, flags, config, sink, sarif, twMerge)
+        : runLint(files, config, flags.reporter, sink, sarif);
+}
+function watchTransform(file, flags, config, sink, twMerge) {
+    const total = totalOf(processFile(file, flags, config, twMerge));
+    if (total > 0) {
+        sink.log(`${timestamp()} ${file} — ${pluralize(total, 'change')} applied`);
     }
-    const watching = flags.watch && !flags.typos && !flags.check;
-    const totals = { fixed: 0, deduped: 0, merged: 0, sorted: 0 };
-    const allFindings = [];
+}
+function runTransforms(files, flags, config, sink, sarif, twMerge) {
+    const totals = emptyCounts();
     const changedFiles = [];
     let hadError = false;
-    if (!watching) {
-        for (const file of files) {
-            try {
-                if (transforming) {
-                    const counts = flags.check
-                        ? await checkFile(file, flags, config, twMerge)
-                        : await processFile(file, flags, config);
-                    totals.fixed += counts.fixed;
-                    totals.deduped += counts.deduped;
-                    totals.merged += counts.merged;
-                    totals.sorted += counts.sorted;
-                    if (totalOf(counts) > 0)
-                        changedFiles.push(file);
-                    if (flags.reporter === 'text') {
-                        if (counts.fixed > 0)
-                            sink.log(`  ${flags.check ? 'would fix' : 'fixed '} ${file} (${pluralize(counts.fixed, 'replacement')})`);
-                        if (counts.deduped > 0)
-                            sink.log(`  ${flags.check ? 'would dedup' : 'deduped'} ${file} (${pluralize(counts.deduped, 'class string')})`);
-                        if (counts.merged > 0)
-                            sink.log(`  ${flags.check ? 'would merge' : 'merged '} ${file} (${pluralize(counts.merged, 'conflict')})`);
-                        if (counts.sorted > 0)
-                            sink.log(`  ${flags.check ? 'would sort' : 'sorted '} ${file} (${pluralize(counts.sorted, 'class string')})`);
-                    }
-                }
-                else {
-                    const findings = analyzeFile(file, config);
-                    allFindings.push(...findings);
-                    if (flags.reporter === 'text') {
-                        for (const f of findings) {
-                            const tag = f.suggestion.isCustomToken ? ' [custom token]' : '';
-                            sink.log(`  ${f.file}:${f.line}:${f.col}  ${f.suggestion.original} → ${f.suggestion.canonical}${tag}`);
-                        }
-                    }
-                }
-            }
-            catch (err) {
-                hadError = true;
-                sink.error(`${file}: ${errMsg(err)}`);
+    for (const file of files) {
+        try {
+            const counts = flags.check
+                ? applyTransforms(readFileSync(file, 'utf8'), flags, config, twMerge)
+                    .counts
+                : processFile(file, flags, config, twMerge);
+            addCounts(totals, counts);
+            if (totalOf(counts) > 0)
+                changedFiles.push(file);
+            if (flags.reporter === 'text') {
+                logTransformCounts(counts, file, flags.check, sink);
             }
         }
-    }
-    if (watching)
-        return startWatch(files, flags, config, sink);
-    if (transforming) {
-        const typoResult = flags.typos
-            ? collectTypos(files, config, sink)
-            : undefined;
-        const totalChanges = totalOf(totals);
-        const exitCode = hadError ||
-            (flags.check && totalChanges > 0) ||
-            (typoResult && (typoResult.findings.length > 0 || typoResult.hadError))
-            ? 1
-            : 0;
-        if (flags.reporter === 'json') {
-            const report = {
-                files: files.length,
-                changedFiles,
-                fixed: totals.fixed,
-                deduped: totals.deduped,
-                merged: totals.merged,
-                sorted: totals.sorted,
-            };
-            if (flags.check)
-                report.check = true;
-            if (typoResult) {
-                report.typoTotal = typoResult.findings.length;
-                report.typos = typoResult.findings;
-            }
-            sink.write(`${JSON.stringify(report, null, 2)}\n`);
-            return { exitCode };
+        catch (err) {
+            hadError = true;
+            sink.error(`${file}: ${errMsg(err)}`);
         }
-        if (flags.reporter === 'sarif') {
-            const doc = typoResult
-                ? typoSarifDocument(typoResult.findings)
-                : sarifDocument([], []);
-            sink.write(`${JSON.stringify(doc, null, 2)}\n`);
-            return { exitCode };
+    }
+    const typoResult = flags.typos
+        ? collectTypos(files, config, sink)
+        : undefined;
+    const totalChanges = totalOf(totals);
+    const result = exitWith(hadError ||
+        (flags.check && totalChanges > 0) ||
+        (typoResult !== undefined &&
+            (typoResult.findings.length > 0 || typoResult.hadError)));
+    if (flags.reporter === 'json') {
+        const report = {
+            files: files.length,
+            changedFiles,
+            ...totals,
+        };
+        if (flags.check)
+            report.check = true;
+        if (typoResult) {
+            report.typoTotal = typoResult.findings.length;
+            report.typos = typoResult.findings;
         }
-        if (flags.check) {
-            if (totalChanges > 0) {
-                sink.log(`\n✖ ${pluralize(totalChanges, 'pending change')} across ${pluralize(changedFiles.length, 'file')} (run without --check to apply)`);
-            }
-            else {
-                sink.log('✓ No pending changes');
-            }
+        writeJson(sink, report);
+        return result;
+    }
+    if (flags.reporter === 'sarif') {
+        const doc = typoResult
+            ? typoSarifDocument(typoResult.findings, sarif)
+            : sarifDocument([], [], sarif);
+        writeJson(sink, doc);
+        return result;
+    }
+    if (flags.check) {
+        sink.log(totalChanges > 0
+            ? `\n✖ ${pluralize(totalChanges, 'pending change')} across ${pluralize(changedFiles.length, 'file')} (run without --check to apply)`
+            : '✓ No pending changes');
+    }
+    else {
+        const parts = [];
+        if (flags.fix)
+            parts.push(pluralize(totals.fixed, 'replacement'));
+        if (flags.dedup)
+            parts.push(pluralize(totals.deduped, 'dedup'));
+        if (flags.merge)
+            parts.push(`${pluralize(totals.merged, 'conflict')} merged`);
+        if (flags.sort)
+            parts.push(`${totals.sorted} sorted`);
+        sink.log(`\n✓ Fixed ${parts.join(', ')} across ${pluralize(files.length, 'file')}`);
+    }
+    if (typoResult)
+        logTyposText(typoResult.findings, sink);
+    return result;
+}
+function runLint(files, config, reporter, sink, sarif) {
+    const findings = [];
+    let hadError = false;
+    for (const file of files) {
+        try {
+            const fileFindings = analyzeFile(file, config);
+            findings.push(...fileFindings);
+            if (reporter === 'text')
+                logFindings(fileFindings, sink);
         }
-        else {
-            const parts = [];
-            if (flags.fix)
-                parts.push(pluralize(totals.fixed, 'replacement'));
-            if (flags.dedup)
-                parts.push(pluralize(totals.deduped, 'dedup'));
-            if (flags.merge)
-                parts.push(`${pluralize(totals.merged, 'conflict')} merged`);
-            if (flags.sort)
-                parts.push(`${totals.sorted} sorted`);
-            sink.log(`\n✓ Fixed ${parts.join(', ')} across ${pluralize(files.length, 'file')}`);
+        catch (err) {
+            hadError = true;
+            sink.error(`${file}: ${errMsg(err)}`);
         }
-        if (typoResult)
-            logTyposText(typoResult.findings, sink);
-        return { exitCode };
     }
-    const totalFindings = allFindings.length;
-    if (flags.reporter === 'json') {
+    if (reporter === 'json') {
         const report = {
             files: files.length,
-            total: totalFindings,
-            findings: allFindings.map((f) => ({
+            total: findings.length,
+            findings: findings.map((f) => ({
                 file: f.file,
                 line: f.line,
                 col: f.col,
@@ -843,41 +595,18 @@ export async function run(argv, cwd, sink = defaultSink) {
                 isCustomToken: f.suggestion.isCustomToken,
             })),
         };
-        sink.write(`${JSON.stringify(report, null, 2)}\n`);
-        return { exitCode: totalFindings > 0 || hadError ? 1 : 0 };
+        writeJson(sink, report);
+        return exitWith(findings.length > 0 || hadError);
     }
-    if (flags.reporter === 'sarif') {
-        const sarifOutput = sarifDocument([
-            {
-                id: 'no-arbitrary-canonical',
-                name: 'NoArbitraryCanonical',
-                shortDescription: {
-                    text: 'Arbitrary value has a canonical Tailwind equivalent',
-                },
-            },
-        ], allFindings.map((f) => ({
-            ruleId: 'no-arbitrary-canonical',
-            message: {
-                text: `${f.suggestion.original} → ${f.suggestion.canonical}`,
-            },
-            locations: [
-                {
-                    physicalLocation: {
-                        artifactLocation: { uri: f.file },
-                        region: { startLine: f.line, startColumn: f.col },
-                    },
-                },
-            ],
-        })));
-        sink.write(`${JSON.stringify(sarifOutput, null, 2)}\n`);
-        return { exitCode: totalFindings > 0 || hadError ? 1 : 0 };
-    }
-    if (totalFindings > 0) {
-        sink.log(`\n✖ Found ${totalFindings} non-canonical class${totalFindings !== 1 ? 'es' : ''}`);
+    if (reporter === 'sarif') {
+        writeJson(sink, findingsSarifDocument(findings, sarif));
+        return exitWith(findings.length > 0 || hadError);
+    }
+    if (findings.length > 0) {
+        sink.log(`\n✖ Found ${findings.length} non-canonical class${findings.length !== 1 ? 'es' : ''}`);
         sink.log('  Run with --fix to auto-replace\n');
-        return { exitCode: 1 };
+        return exitWith(true);
     }
     sink.log('✓ No non-canonical classes found');
-    return { exitCode: hadError ? 1 : 0 };
+    return exitWith(hadError);
 }
-//# sourceMappingURL=cli.js.map