tailwind-canonical 0.4.0 → 0.4.2

package/README.md

@@ -125,9 +125,19 @@ Detects semantic inconsistencies visible only at project scale — it never modi
 
 ```bash
 npx tailwind-canonical --analyze ./src
-# Warning: 3 red color variants used for text: text-red-500 (4), text-rose-500 (1), text-red-600 (2)
-# Warning: px inconsistency: px-4 (8 files) vs px-3 (2 files)
-# Warning: z inconsistency: z-[100] (3 files) vs z-[200] (1 file) vs z-[50] (2 files)
+# tailwind-canonical analyze
+# Files analyzed: 42
+# Issue groups: 3 (1 color, 2 scales, 0 patterns)
+#
+# Color variants
+#   - text/red: text-red-500 x4, text-rose-500 x1
+#
+# Scale inconsistency groups
+#   - px: 2 values, 10 uses, 10 files
+#     Top: px-4 (8 uses, 8 files), px-3 (2 uses, 2 files)
+#
+# Rare scale values
+#   - px-11: 3 uses in 1 file (608 px uses total); e.g. src/Dialog.tsx
 ```
 
 Three detectors:
@@ -136,6 +146,7 @@ Three detectors:
 |---|---|
 | Color variants | Multiple shades/colors of the same hue family used for one property (`text`, `bg`, `border`, …) |
 | Scale inconsistency | Competing values for the same spacing / `gap` / `z` property across files |
+| Rare scale values | Low-frequency scale values inside otherwise common properties (`ml-13`, `gap-24`, `px-11`, …) |
 | Repeated patterns | Identical class combinations recurring across 3+ files |
 
 Pairs with `--reporter json` for machine-readable output. Exits `1` when any inconsistency is found.
@@ -160,6 +171,10 @@ npx tailwind-canonical --analyze --reporter json ./src
         { "value": "3", "count": 2, "files": ["src/IconButton.tsx"] }
       ] }
   ],
+  "rareScaleValues": [
+    { "property": "px", "value": "11", "className": "px-11",
+      "count": 3, "files": ["src/Dialog.tsx"], "propertyCount": 608 }
+  ],
   "combinations": []
 }
 ```
@@ -182,8 +197,8 @@ Variants (`hover:`, `sm:`, `focus:`) are sorted after base classes, with respons
 
 Override the category order via config. Categories you omit (and unknown classes) sort to the end, preserving their original relative order. Variants are always sorted after base classes regardless of order.
 
-```js
-// tailwind-canonical.config.js
+```ts
+// tailwind-canonical.config.ts
 export default {
   sortOrder: [
     'display',
@@ -254,9 +269,9 @@ Non-divisible values (`h-[22px]`, `px-[7px]`) are left untouched.
 
 ## Config
 
-Create `tailwind-canonical.config.js` at the root:
+Create `tailwind-canonical.config.ts` at the root:
 
-```js
+```ts
 export default {
   customTextTokens: {
     10: '3xs',
@@ -269,6 +284,24 @@ export default {
   attributeNames: ['className', 'class', ':class', 'tw'],
   // Support utility function wrappers
   functionNames: ['cn', 'clsx', 'cva'],
+  // Optional CLI defaults, so `tailwind-canonical` is enough locally/CI
+  defaultCommand: {
+    fix: true,
+    dedup: true,
+    merge: true,
+    sort: true,
+    targets: ['./src'],
+  },
+  // Tune --analyze reporting
+  analyze: {
+    maxScaleGroups: 8,
+    maxScaleValues: 5,
+    maxRareValues: 12,
+    maxPatterns: 10,
+    minRareScalePropertyOccurrences: 10,
+    rareScaleMaxFiles: 2,
+    rareScaleMaxCount: 3,
+  },
   // Never suggest replacements for classes matching these patterns
   ignorePatterns: [/^font-/, /-\[var\(/],
 }
@@ -280,6 +313,26 @@ export default {
 
 `functionNames` enables scanning inside utility function calls like `cn(...)` and `clsx(...)`.
 
+`defaultCommand` lets the config provide the CLI defaults. With the example
+above, running `tailwind-canonical` is equivalent to
+`tailwind-canonical --fix --dedup --merge --sort ./src`. Explicit CLI flags and
+targets still override the config, so `tailwind-canonical --typos ./app` runs
+only typo detection on `./app`.
+
+`analyze` controls project-scale consistency reporting. `maxScaleGroups`,
+`maxScaleValues`, `maxRareValues`, and `maxPatterns` keep terminal output
+compact. `minRareScalePropertyOccurrences`, `rareScaleMaxFiles`, and
+`rareScaleMaxCount` control which low-frequency values are surfaced as rare
+scale values. Defaults are conservative: only properties with 10+ total
+occurrences are considered, and a value is rare when it appears in at most 2
+files and at most 3 times.
+
+The older top-level rare-value keys are still accepted for compatibility, but
+new configs should prefer `analyze`.
+
+`tailwind-canonical.config.js` is still loaded as a fallback when no TypeScript
+config exists.
+
 ## ESLint plugin
 
 ```js

package/dist/cli/cli.d.ts

@@ -19,6 +19,9 @@ type Flags = {
     reporter: Reporter;
     targets: string[];
     error?: string;
+    hasExplicitMode: boolean;
+    hasExplicitReporter: boolean;
+    hasExplicitWatch: boolean;
 };
 export declare function parseArgs(argv: string[]): Flags;
 /**

package/dist/cli/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli/cli.ts"],"names":[],"mappings":"AAuBA,MAAM,MAAM,IAAI,GAAG;IACjB,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACzB,KAAK,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3B,KAAK,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAC5B,CAAC;AAQF,MAAM,MAAM,SAAS,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEjE,KAAK,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE1C,KAAK,KAAK,GAAG;IACX,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,QAAQ,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAsFF,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,KAAK,CA0C/C;AASD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,EAAE,CAwBnD;AAyLD,wBAAsB,GAAG,CACvB,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,IAAkB,GACvB,OAAO,CAAC,SAAS,CAAC,CAiMpB"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli/cli.ts"],"names":[],"mappings":"AAwBA,MAAM,MAAM,IAAI,GAAG;IACjB,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACzB,KAAK,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3B,KAAK,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAC5B,CAAC;AAQF,MAAM,MAAM,SAAS,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEjE,KAAK,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE1C,KAAK,KAAK,GAAG;IACX,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,QAAQ,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,OAAO,CAAC;IACzB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAmJF,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,KAAK,CAwD/C;AA6CD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,EAAE,CAwBnD;AAgbD,wBAAsB,GAAG,CACvB,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,IAAkB,GACvB,OAAO,CAAC,SAAS,CAAC,CAwLpB"}

package/dist/cli/cli.js

@@ -1,4 +1,4 @@
-import { watch as fsWatch } from 'node:fs';
+import { watch as fsWatch, readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { analyzeFile } from '../core/analyzer.js';
 import { toClassStringOpts } from '../core/class-strings.js';
@@ -17,6 +17,39 @@ const defaultSink = {
     error: (s) => console.error(s),
     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);
 }
@@ -29,6 +62,24 @@ function timestamp() {
     return `[${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}]`;
 }
 const REPORTERS = ['text', 'json', 'sarif'];
+const MODE_FLAGS = [
+    '--fix',
+    '--merge',
+    '--dedup',
+    '--sort',
+    '--analyze',
+    '--typos',
+];
+const KNOWN_FLAGS = new Set([
+    '--fix',
+    '--merge',
+    '--dedup',
+    '--sort',
+    '--watch',
+    '--analyze',
+    '--typos',
+    '--reporter',
+]);
 function isReporter(value) {
     return REPORTERS.includes(value);
 }
@@ -58,6 +109,14 @@ export function parseArgs(argv) {
             error = `Unknown reporter: ${reporterRaw} (expected ${REPORTERS.join('|')})`;
         }
     }
+    if (!error) {
+        const unknown = argv.find((a, i) => a.startsWith('--') &&
+            !consumed.has(i) &&
+            !KNOWN_FLAGS.has(a) &&
+            !a.startsWith('--reporter='));
+        if (unknown)
+            error = `Unknown flag: ${unknown}`;
+    }
     const targets = argv.filter((a, i) => !(a.startsWith('--') || consumed.has(i)));
     return {
         fix: argv.includes('--fix'),
@@ -70,8 +129,45 @@ export function parseArgs(argv) {
         reporter,
         targets,
         error,
+        hasExplicitMode: MODE_FLAGS.some((flag) => argv.includes(flag)),
+        hasExplicitReporter: reporterRaw !== undefined,
+        hasExplicitWatch: argv.includes('--watch'),
+    };
+}
+function applyDefaultCommand(flags, config) {
+    const defaults = config.defaultCommand;
+    if (!defaults)
+        return flags;
+    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),
+        reporter: flags.hasExplicitReporter
+            ? flags.reporter
+            : (defaults.reporter ?? flags.reporter),
+        targets: flags.targets.length > 0 ? flags.targets : (defaults.targets ?? []),
     };
 }
+function resolveTarget(cwd, target) {
+    if (target.startsWith('!'))
+        return `!${resolve(cwd, target.slice(1))}`;
+    return resolve(cwd, target);
+}
 const TRANSFORM_FLAGS = [
     { key: 'fix', flag: '--fix' },
     { key: 'dedup', flag: '--dedup' },
@@ -128,6 +224,30 @@ function runTypos(files, config, reporter, sink) {
         sink.write(`${JSON.stringify(report, null, 2)}\n`);
         return { exitCode: findings.length > 0 || hadError ? 1 : 0 };
     }
+    if (reporter === 'sarif') {
+        const sarifOutput = 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 },
+                    },
+                },
+            ],
+        })));
+        sink.write(`${JSON.stringify(sarifOutput, null, 2)}\n`);
+        return { exitCode: findings.length > 0 || hadError ? 1 : 0 };
+    }
     for (const f of findings) {
         sink.log(`  ${f.file}:${f.line}:${f.col}  ${f.original} → ${f.suggestion} [typo]`);
     }
@@ -155,6 +275,118 @@ async function processFile(file, flags, config) {
 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 findUnconfiguredClassFunctions(files, config) {
+    const configured = new Set(config.functionNames ?? []);
+    const missing = KNOWN_CLASS_FUNCTIONS.filter((name) => !configured.has(name));
+    if (missing.length === 0)
+        return [];
+    const found = new Set();
+    const re = new RegExp(`\\b(${missing.join('|')})\\s*\\(`);
+    for (const file of files) {
+        let content;
+        try {
+            content = readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const match = content.match(re);
+        if (match?.[1])
+            found.add(match[1]);
+    }
+    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) {
     let hadError = false;
     const options = toConsistencyOptions(config);
@@ -165,31 +397,93 @@ function runAnalyze(files, config, reporter, sink) {
     const issueCount = report.colorVariants.length +
         report.scaleInconsistencies.length +
         report.combinations.length;
+    const unconfiguredFunctions = findUnconfiguredClassFunctions(files, config);
+    if (unconfiguredFunctions.length > 0) {
+        const calls = unconfiguredFunctions
+            .map((name) => `${name}(...)`)
+            .join(', ');
+        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 };
     }
-    for (const group of report.colorVariants) {
-        const tokens = group.variants
-            .map((v) => `${group.property}-${v.token} (${v.count})`)
-            .join(', ');
-        sink.log(`  Warning: ${group.variants.length} ${group.family} color variants used for ${group.property}: ${tokens}`);
-    }
-    for (const scale of report.scaleInconsistencies) {
-        const values = scale.values
-            .map((v) => `${scale.property}-${v.value} (${pluralize(v.files.length, 'file')})`)
-            .join(' vs ');
-        sink.log(`  Warning: ${scale.property} inconsistency: ${values}`);
-    }
-    for (const combo of report.combinations) {
-        sink.log(`  Pattern: "${combo.classes.join(' ')}" repeated in ${pluralize(combo.files.length, 'file')}`);
-    }
-    if (issueCount === 0) {
-        sink.log('✓ No cross-file inconsistencies found');
-    }
-    else {
-        sink.log(`\n✖ Found ${pluralize(issueCount, 'consistency issue')} across ${pluralize(report.filesAnalyzed, 'file')}`);
+    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) {
@@ -235,18 +529,27 @@ function startWatch(files, flags, config, sink) {
             }, 50));
         });
     }
-    process.on('SIGINT', () => {
+    process.once('SIGINT', () => {
         sink.log('\nWatcher stopped.');
         process.exit(0);
     });
     return { exitCode: 0, watching: true };
 }
 export async function run(argv, cwd, sink = defaultSink) {
-    const flags = parseArgs(argv);
+    let flags = parseArgs(argv);
     if (flags.error) {
         sink.error(flags.error);
         return { exitCode: 1 };
     }
+    let config;
+    try {
+        config = await loadConfig(cwd);
+    }
+    catch (err) {
+        sink.error(`tailwind-canonical: ${err instanceof Error ? err.message : String(err)}`);
+        return { exitCode: 1 };
+    }
+    flags = applyDefaultCommand(flags, config);
     if (flags.targets.length === 0) {
         sink.error(USAGE);
         return { exitCode: 1 };
@@ -260,18 +563,11 @@ export async function run(argv, cwd, sink = defaultSink) {
             return { exitCode: 1 };
         }
     }
-    let config;
-    try {
-        config = await loadConfig(cwd);
-    }
-    catch (err) {
-        sink.error(`tailwind-canonical: ${err instanceof Error ? err.message : String(err)}`);
-        return { exitCode: 1 };
-    }
     for (const warning of flagWarnings(flags)) {
         sink.error(`Warning: ${warning}`);
     }
-    const files = await resolveTargets(flags.targets);
+    const targetPaths = flags.targets.map((target) => resolveTarget(cwd, target));
+    const files = await resolveTargets(targetPaths);
     if (flags.analyze)
         return runAnalyze(files, config, flags.reporter, sink);
     if (flags.typos)
@@ -365,43 +661,28 @@ export async function run(argv, cwd, sink = defaultSink) {
         return { exitCode: totalFindings > 0 || hadError ? 1 : 0 };
     }
     if (flags.reporter === 'sarif') {
-        const sarifOutput = {
-            $schema: SARIF_SCHEMA,
-            version: '2.1.0',
-            runs: [
+        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: [
                 {
-                    tool: {
-                        driver: {
-                            name: 'tailwind-canonical',
-                            informationUri: 'https://github.com/peak-lab/tailwind-canonical',
-                            rules: [
-                                {
-                                    id: 'no-arbitrary-canonical',
-                                    name: 'NoArbitraryCanonical',
-                                    shortDescription: {
-                                        text: 'Arbitrary value has a canonical Tailwind equivalent',
-                                    },
-                                },
-                            ],
-                        },
+                    physicalLocation: {
+                        artifactLocation: { uri: f.file },
+                        region: { startLine: f.line, startColumn: f.col },
                     },
-                    results: 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 };
     }