@urbicon-ui/mcp-server 6.1.5 → 6.1.6

package/src/design-linter/linter.test.ts

@@ -1,257 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { lintDesign, maskComments } from './linter.js';
-import type { Finding } from './types.js';
-
-function ids(findings: Finding[]): string[] {
-  return findings.map((f) => f.ruleId);
-}
-function has(findings: Finding[], ruleId: string): boolean {
-  return findings.some((f) => f.ruleId === ruleId);
-}
-
-describe('raw-tailwind-color', () => {
-  it('flags numbered chromatic palette utilities', () => {
-    const { findings } = lintDesign(
-      '<div class="bg-blue-500 text-red-600 border-l-amber-400">x</div>'
-    );
-    expect(findings.filter((f) => f.ruleId === 'raw-tailwind-color')).toHaveLength(3);
-  });
-  it('flags opacity-suffixed raw colours', () => {
-    expect(has(lintDesign('<div class="bg-green-500/40">').findings, 'raw-tailwind-color')).toBe(
-      true
-    );
-  });
-  it('does NOT flag library tokens (intents, neutral, surfaces)', () => {
-    const { findings } = lintDesign(
-      '<div class="bg-primary-500 bg-neutral-100 bg-surface-base text-success border-border-subtle">'
-    );
-    expect(has(findings, 'raw-tailwind-color')).toBe(false);
-  });
-});
-
-describe('dark-mode-override', () => {
-  it('flags dark: variants', () => {
-    expect(
-      has(
-        lintDesign('<div class="bg-white dark:bg-surface-elevated">').findings,
-        'dark-mode-override'
-      )
-    ).toBe(true);
-  });
-  it('flags the important-modifier form dark:!', () => {
-    expect(
-      has(lintDesign('<div class="dark:!bg-surface-elevated">').findings, 'dark-mode-override')
-    ).toBe(true);
-  });
-  it('does NOT flag plain semantic tokens', () => {
-    expect(
-      has(lintDesign('<div class="bg-surface-elevated">').findings, 'dark-mode-override')
-    ).toBe(false);
-  });
-});
-
-describe('focus-not-visible', () => {
-  it('flags focus: and group-focus:', () => {
-    expect(has(lintDesign('<button class="focus:ring-2">').findings, 'focus-not-visible')).toBe(
-      true
-    );
-    expect(
-      has(lintDesign('<div class="group-focus:opacity-100">').findings, 'focus-not-visible')
-    ).toBe(true);
-  });
-  it('does NOT flag focus-visible: or focus-within:', () => {
-    const { findings } = lintDesign(
-      '<button class="focus-visible:ring-2 focus-within:bg-surface-hover">'
-    );
-    expect(has(findings, 'focus-not-visible')).toBe(false);
-  });
-});
-
-describe('hardcoded-z-index', () => {
-  it('flags numeric and bracketed z-index', () => {
-    expect(has(lintDesign('<div class="z-10">').findings, 'hardcoded-z-index')).toBe(true);
-    expect(has(lintDesign('<div class="z-[999]">').findings, 'hardcoded-z-index')).toBe(true);
-  });
-  it('does NOT flag the z-index token form or z-auto', () => {
-    const { findings } = lintDesign('<div class="z-[var(--z-modal)] z-auto">');
-    expect(has(findings, 'hardcoded-z-index')).toBe(false);
-  });
-});
-
-describe('dynamic-class-interpolation', () => {
-  it('flags interpolated Tailwind utility fragments', () => {
-    expect(
-      has(
-        lintDesign("<div class=\"gap-{isHero ? '4' : '3'}\">").findings,
-        'dynamic-class-interpolation'
-      )
-    ).toBe(true);
-    expect(
-      has(lintDesign('<div class={`py-${pad}`}>').findings, 'dynamic-class-interpolation')
-    ).toBe(true);
-  });
-  it('does NOT flag interpolation that is not a Tailwind root (ids, data keys)', () => {
-    const { findings } = lintDesign('<label for={`field-${id}`}>');
-    expect(has(findings, 'dynamic-class-interpolation')).toBe(false);
-  });
-});
-
-describe('token-hallucination', () => {
-  it('flags invented status-* and -fg tokens', () => {
-    expect(has(lintDesign('<div class="bg-status-danger">').findings, 'token-hallucination')).toBe(
-      true
-    );
-    expect(has(lintDesign('<div class="text-success-fg">').findings, 'token-hallucination')).toBe(
-      true
-    );
-  });
-  it('flags intent-with-bad-suffix and namespace typos', () => {
-    expect(has(lintDesign('<div class="bg-primary-muted">').findings, 'token-hallucination')).toBe(
-      true
-    );
-    expect(has(lintDesign('<div class="bg-surface-raised">').findings, 'token-hallucination')).toBe(
-      true
-    );
-  });
-  it('does NOT flag valid tokens', () => {
-    const valid =
-      '<div class="bg-surface-subtle text-text-primary bg-primary bg-primary-500 text-success bg-feedback-success-subtle border-border-strong">';
-    expect(has(lintDesign(valid).findings, 'token-hallucination')).toBe(false);
-  });
-  it('does NOT flag genuine Tailwind utilities or arbitrary values', () => {
-    const { findings } = lintDesign(
-      '<div class="bg-transparent bg-[#fff] text-sm bg-cover from-transparent">'
-    );
-    expect(has(findings, 'token-hallucination')).toBe(false);
-  });
-  it('does NOT flag font-size cores sharing the text- namespace', () => {
-    const { findings } = lintDesign('<div class="bg-text-sm text-text-2xl border-text-base">');
-    expect(has(findings, 'token-hallucination')).toBe(false);
-  });
-  it('keeps the opacity suffix in the reported match', () => {
-    const f = lintDesign('<div class="bg-surface-raised/50">').findings.find(
-      (x) => x.ruleId === 'token-hallucination'
-    );
-    expect(f?.match).toBe('bg-surface-raised/50');
-  });
-  it('flags shadcn/ui vocabulary — the top hallucination source (round-3 finding)', () => {
-    const code =
-      '<div class="text-foreground bg-accent text-muted-foreground bg-card bg-surface text-fg text-fg-muted border-card-foreground bg-destructive">x</div>';
-    const matches = lintDesign(code)
-      .findings.filter((f) => f.ruleId === 'token-hallucination')
-      .map((f) => f.match);
-    for (const t of [
-      'text-foreground',
-      'bg-accent',
-      'text-muted-foreground',
-      'bg-card',
-      'bg-surface',
-      'text-fg',
-      'text-fg-muted',
-      'border-card-foreground',
-      'bg-destructive'
-    ]) {
-      expect(matches, t).toContain(t);
-    }
-  });
-});
-
-describe('heuristics', () => {
-  it('flags an intent rainbow of ≥4 chromatic background hues', () => {
-    const code =
-      '<div class="bg-primary"></div><div class="bg-success"></div><div class="bg-warning"></div><div class="bg-danger"></div>';
-    expect(has(lintDesign(code).findings, 'intent-rainbow')).toBe(true);
-  });
-  it('does NOT count neutral backgrounds toward the rainbow', () => {
-    const code =
-      '<div class="bg-neutral-100"></div><div class="bg-neutral-200"></div><div class="bg-surface-base"></div><div class="bg-surface-elevated"></div>';
-    expect(has(lintDesign(code).findings, 'intent-rainbow')).toBe(false);
-  });
-  it('flags uniform spacing (one rhythm tier)', () => {
-    const code =
-      '<div class="gap-4"><div class="gap-4"></div><div class="gap-4"></div><div class="gap-4"></div><div class="gap-4"></div><div class="gap-4"></div></div>';
-    expect(has(lintDesign(code).findings, 'spacing-uniform')).toBe(true);
-  });
-  it('does NOT flag two-tier spacing', () => {
-    const code =
-      '<div class="gap-10"><div class="gap-3"></div><div class="gap-3"></div><div class="gap-10"></div><div class="gap-3"></div><div class="gap-10"></div></div>';
-    expect(has(lintDesign(code).findings, 'spacing-uniform')).toBe(false);
-  });
-  it('flags identical Cards (no visual-weight variation)', () => {
-    const card = '<Card variant="elevated" padding="md">x</Card>';
-    expect(has(lintDesign(card.repeat(4)).findings, 'card-monotony')).toBe(true);
-  });
-  it('does NOT flag differentiated Cards', () => {
-    const code =
-      '<Card variant="elevated" padding="lg">x</Card><Card variant="outlined" padding="md">x</Card><Card variant="outlined" padding="md">x</Card><Card variant="quiet" padding="sm">x</Card>';
-    expect(has(lintDesign(code).findings, 'card-monotony')).toBe(false);
-  });
-  it('nudges when surfaces exist but no radius strategy does', () => {
-    const code = '<Card>a</Card><Card>b</Card><Card>c</Card>';
-    expect(has(lintDesign(code).findings, 'no-radius-strategy')).toBe(true);
-  });
-  it('does NOT nudge once a radius override is present', () => {
-    const code =
-      '<Card class="rounded-xl">a</Card><Card class="rounded-xl">b</Card><Card class="rounded-xl">c</Card>';
-    expect(has(lintDesign(code).findings, 'no-radius-strategy')).toBe(false);
-  });
-  it('does NOT treat bordered table rows / dividers as surfaces (no false radius nudge)', () => {
-    const code =
-      '<table><tr class="border-b"><td>a</td></tr><tr class="border-b"><td>b</td></tr><tr class="border-b"><td>c</td></tr></table>';
-    expect(has(lintDesign(code).findings, 'no-radius-strategy')).toBe(false);
-  });
-  it('can be skipped via skipHeuristics', () => {
-    const code = '<Card variant="elevated" padding="md">x</Card>'.repeat(4);
-    const { findings } = lintDesign(code, { skipHeuristics: true });
-    expect(findings.every((f) => f.kind === 'deterministic')).toBe(true);
-  });
-});
-
-describe('comment masking', () => {
-  it('ignores violations inside HTML and block comments', () => {
-    const code =
-      '<!-- class="focus:ring-2 bg-blue-500" --><div class="bg-surface-base">/* z-50 */</div>';
-    const { findings } = lintDesign(code);
-    expect(findings).toHaveLength(0);
-  });
-  it('keeps line numbers correct after masking', () => {
-    const masked = maskComments('a\n<!--\nx\n-->\nfocus:ring');
-    expect(masked.split('\n')).toHaveLength(5);
-  });
-});
-
-describe('scoring', () => {
-  it('scores clean code 100', () => {
-    const { score } = lintDesign('<div class="bg-surface-base text-text-primary">clean</div>');
-    expect(score).toBe(100);
-  });
-  it('deducts per finding and floors at 0', () => {
-    const oneError = lintDesign('<div class="bg-blue-500">');
-    expect(oneError.score).toBe(90);
-    // Per-line dedupe collapses identical hits on one line, so spread distinct hits across lines.
-    const many = lintDesign(
-      Array.from({ length: 12 }, () => '<div class="bg-blue-500">').join('\n')
-    );
-    expect(many.score).toBe(0);
-  });
-  it('reports severity counts', () => {
-    const { counts } = lintDesign('<div class="bg-blue-500 bg-status-x">');
-    expect(counts.error).toBeGreaterThanOrEqual(1);
-    expect(counts.warning).toBeGreaterThanOrEqual(1);
-  });
-});
-
-describe('rule metadata', () => {
-  it('every finding carries a fix hint', () => {
-    const code =
-      '<button class="bg-blue-500 dark:bg-red-500 focus:ring z-50 gap-{x} bg-status-bad">';
-    for (const f of lintDesign(code).findings) {
-      expect(f.fix.length).toBeGreaterThan(0);
-      expect(f.ruleId.length).toBeGreaterThan(0);
-    }
-  });
-  it('produces a stable id ordering for the same input', () => {
-    const code = '<div class="z-50 bg-blue-500">';
-    expect(ids(lintDesign(code).findings)).toEqual(ids(lintDesign(code).findings));
-  });
-});

package/src/design-linter/linter.ts

@@ -1,62 +0,0 @@
-/**
- * The design linter engine: masks comments, runs the deterministic rules and the
- * distribution heuristics, and reduces the findings to a 0–100 score. Pure and
- * dependency-free so it is trivially unit-testable (one of the explicit wins of
- * a linter over prose guidance — see docs/DESIGN-MCP.md, Option B).
- */
-
-import { runHeuristics } from './heuristics.js';
-import { RULES } from './rules.js';
-import type { Finding, LintOptions, LintReport, Severity } from './types.js';
-
-/** Per-severity score deduction. Errors dominate (they are real defects). Centralised for tuning. */
-export const SCORE_WEIGHTS: Record<Severity, number> = {
-  error: 10,
-  warning: 5,
-  info: 2
-};
-
-/**
- * Blank out comment bodies while preserving newlines (so line numbers stay
- * correct) — keeps the rules from firing on `focus:` in a `<!-- … -->` note or a
- * `/* … *\/` block. Line comments are intentionally left alone: masking `//`
- * safely (without eating `https://`) is not worth the complexity for v1.
- */
-export function maskComments(code: string): string {
-  const blankKeepNewlines = (s: string) => s.replace(/[^\n]/g, ' ');
-  return code
-    .replace(/<!--[\s\S]*?-->/g, blankKeepNewlines)
-    .replace(/\/\*[\s\S]*?\*\//g, blankKeepNewlines);
-}
-
-const SEVERITY_ORDER: Record<Severity, number> = { error: 0, warning: 1, info: 2 };
-
-/** Lint one code unit. Returns findings, a score, and severity counts. */
-export function lintDesign(code: string, opts: LintOptions = {}): LintReport {
-  const masked = maskComments(code);
-  const lines = masked.split('\n');
-
-  const findings: Finding[] = [];
-  for (const rule of RULES) {
-    findings.push(...rule.check(lines, masked));
-  }
-  if (!opts.skipHeuristics) {
-    findings.push(...runHeuristics(masked));
-  }
-
-  findings.sort((a, b) => {
-    const lineDiff = (a.line ?? Infinity) - (b.line ?? Infinity);
-    if (lineDiff !== 0) return lineDiff;
-    return SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity];
-  });
-
-  const counts = { error: 0, warning: 0, info: 0 };
-  let deduction = 0;
-  for (const f of findings) {
-    counts[f.severity]++;
-    deduction += SCORE_WEIGHTS[f.severity];
-  }
-  const score = Math.max(0, 100 - deduction);
-
-  return { findings, score, counts, filename: opts.filename };
-}

package/src/design-linter/rules.ts

@@ -1,348 +0,0 @@
-/**
- * Deterministic design rules. Each is a fact about the code — a regex/string
- * match with no judgement — so it can carry `error`/`warning` severity and be
- * covered by regression tests. The prose source is the Anti-Patterns section of
- * `design-system/principles.md` plus the documented known failure modes
- * (token hallucination, dynamic Tailwind classes).
- */
-
-import {
-  INTENT_NAMES,
-  INTENT_PREFIXES,
-  KNOWN_BAD_NAMESPACES,
-  KNOWN_FOREIGN_CORES,
-  SEMANTIC_NAMESPACES,
-  VALID_TOKEN_CORES
-} from './tokens.js';
-import type { Finding, Rule } from './types.js';
-
-const SHADCN_FIX =
-  'This is shadcn/ui vocabulary, not Urbicon UI. Use surface tokens (`bg-surface-base`/`-elevated`), text tokens (`text-text-primary`/`-secondary`), or intents (`bg-primary`, `text-success`).';
-
-/** shadcn/ui-family cores (bare set + `-foreground` suffix + `fg`/`fg-`). */
-function isForeignVocab(core: string): boolean {
-  return (
-    KNOWN_FOREIGN_CORES.has(core) ||
-    core.endsWith('-foreground') ||
-    core === 'fg' ||
-    core.startsWith('fg-')
-  );
-}
-
-/** Tailwind's default chromatic palette names — none are Urbicon UI tokens. `neutral` is ours, so it is excluded. */
-const RAW_PALETTE =
-  'slate|gray|zinc|stone|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose';
-
-/** Colour-bearing Tailwind prefixes (longest first so `border-l` wins over `border`). */
-const COLOR_PREFIXES = [
-  'ring-offset',
-  'border-x',
-  'border-y',
-  'border-t',
-  'border-r',
-  'border-b',
-  'border-l',
-  'border-s',
-  'border-e',
-  'bg',
-  'text',
-  'border',
-  'ring',
-  'divide',
-  'outline',
-  'decoration',
-  'fill',
-  'stroke',
-  'from',
-  'via',
-  'to',
-  'accent',
-  'caret',
-  'placeholder'
-];
-
-/** Tailwind utility roots that take a scale/value — used to catch broken dynamic interpolation. */
-const DYNAMIC_UTILITY_ROOTS = [
-  'gap',
-  'gap-x',
-  'gap-y',
-  'space-x',
-  'space-y',
-  'p',
-  'px',
-  'py',
-  'pt',
-  'pb',
-  'pl',
-  'pr',
-  'm',
-  'mx',
-  'my',
-  'mt',
-  'mb',
-  'ml',
-  'mr',
-  'w',
-  'h',
-  'min-w',
-  'min-h',
-  'max-w',
-  'max-h',
-  'size',
-  'text',
-  'bg',
-  'border',
-  'rounded',
-  'grid-cols',
-  'grid-rows',
-  'col-span',
-  'row-span',
-  'top',
-  'left',
-  'right',
-  'bottom',
-  'inset',
-  'z',
-  'leading',
-  'tracking',
-  'opacity',
-  'scale',
-  'rotate',
-  'translate-x',
-  'translate-y',
-  'duration',
-  'delay'
-];
-
-function dedupeByLine(findings: Finding[]): Finding[] {
-  const seen = new Set<string>();
-  const out: Finding[] = [];
-  for (const f of findings) {
-    const key = `${f.ruleId}:${f.line}:${f.match}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push(f);
-  }
-  return out;
-}
-
-const rawTailwindColor: Rule = {
-  id: 'raw-tailwind-color',
-  severity: 'error',
-  description: 'Raw Tailwind palette colour (e.g. `bg-blue-500`) instead of a semantic token.',
-  check(lines) {
-    // Trailing `(?![a-z0-9-])` (not `\b`) so an optional `/NN` opacity suffix stays in the match.
-    const re = new RegExp(
-      `\\b(?:${COLOR_PREFIXES.join('|')})-(?:${RAW_PALETTE})-(?:50|100|200|300|400|500|600|700|800|900|950)(?:\\/\\d{1,3})?(?![a-z0-9-])`,
-      'g'
-    );
-    const findings: Finding[] = [];
-    lines.forEach((line, i) => {
-      for (const m of line.matchAll(re)) {
-        findings.push({
-          ruleId: this.id,
-          severity: this.severity,
-          kind: 'deterministic',
-          message: `Raw Tailwind colour \`${m[0]}\` bypasses the token system (no dark-mode adaptation, no theming).`,
-          fix: 'Use a semantic token: `bg-surface-*`, `text-text-*`, `border-border-*`, or an intent (`bg-primary`, `text-success`).',
-          line: i + 1,
-          match: m[0]
-        });
-      }
-    });
-    return dedupeByLine(findings);
-  }
-};
-
-const darkModeOverride: Rule = {
-  id: 'dark-mode-override',
-  severity: 'error',
-  description: 'Manual `dark:` override instead of automatic `light-dark()` semantic tokens.',
-  check(lines) {
-    // `!` covers the Tailwind important modifier (`dark:!bg-…`).
-    const re = /\bdark:[a-z[!]/g;
-    const findings: Finding[] = [];
-    lines.forEach((line, i) => {
-      for (const m of line.matchAll(re)) {
-        findings.push({
-          ruleId: this.id,
-          severity: this.severity,
-          kind: 'deterministic',
-          message:
-            'Manual `dark:` override. Dark mode resolves automatically via `light-dark()` semantic tokens.',
-          fix: 'Remove the `dark:` variant and rely on semantic tokens (`bg-surface-elevated` etc.), which already switch.',
-          line: i + 1,
-          match: m[0].slice(0, -1)
-        });
-      }
-    });
-    return dedupeByLine(findings);
-  }
-};
-
-const focusNotVisible: Rule = {
-  id: 'focus-not-visible',
-  severity: 'error',
-  description: 'Plain `focus:` ring instead of keyboard-only `focus-visible:`.',
-  check(lines) {
-    // `focus:` followed by a utility start, but never `focus-visible:`/`focus-within:`
-    // (those contain `focus-`, not `focus:`). Catches `group-focus:` / `peer-focus:` too.
-    const re = /\bfocus:(?=[a-z[])/g;
-    const findings: Finding[] = [];
-    lines.forEach((line, i) => {
-      for (const _ of line.matchAll(re)) {
-        findings.push({
-          ruleId: this.id,
-          severity: this.severity,
-          kind: 'deterministic',
-          message:
-            '`focus:` shows a focus ring on mouse clicks too. Keyboard-only rings are the house style.',
-          fix: 'Use `focus-visible:` instead of `focus:`.',
-          line: i + 1,
-          match: 'focus:'
-        });
-      }
-    });
-    return dedupeByLine(findings);
-  }
-};
-
-const hardcodedZIndex: Rule = {
-  id: 'hardcoded-z-index',
-  severity: 'error',
-  description: 'Hardcoded z-index instead of a `z-[var(--z-*)]` token.',
-  check(lines) {
-    // `z-10`, `z-50`, `z-[999]` — but not `z-[var(--z-modal)]` or `z-auto`.
-    // Trailing `(?![\w-])` (not `\b`) so the bracket form terminates correctly after `]`.
-    const re = /\bz-(?:\d{1,4}|\[\d{1,4}\])(?![\w-])/g;
-    const findings: Finding[] = [];
-    lines.forEach((line, i) => {
-      for (const m of line.matchAll(re)) {
-        findings.push({
-          ruleId: this.id,
-          severity: this.severity,
-          kind: 'deterministic',
-          message: `Hardcoded z-index \`${m[0]}\` collides with the layering scale and can sit behind/above the wrong overlay.`,
-          fix: 'Use a z-index token: `z-[var(--z-modal)]`, `z-[var(--z-dropdown)]`, `z-[var(--z-tooltip)]`, …',
-          line: i + 1,
-          match: m[0]
-        });
-      }
-    });
-    return dedupeByLine(findings);
-  }
-};
-
-const dynamicClassInterpolation: Rule = {
-  id: 'dynamic-class-interpolation',
-  severity: 'error',
-  description:
-    'String-interpolated Tailwind class fragment (e.g. `gap-{x}`) — never compiled by Tailwind.',
-  check(lines) {
-    // A Tailwind utility root immediately glued to a `{` or `${` interpolation.
-    // Tailwind needs static class names; `gap-${x}` produces no CSS at all.
-    const re = new RegExp(`\\b(?:${DYNAMIC_UTILITY_ROOTS.join('|')})-(\\$\\{|\\{)`, 'g');
-    const findings: Finding[] = [];
-    lines.forEach((line, i) => {
-      for (const m of line.matchAll(re)) {
-        findings.push({
-          ruleId: this.id,
-          severity: this.severity,
-          kind: 'deterministic',
-          message: `Interpolated class fragment \`${m[0]}…\` — Tailwind only compiles static class names, so this utility is never generated.`,
-          fix: "Switch the whole class string per state: `class={isHero ? 'gap-4' : 'gap-3'}` — keep each utility a complete literal.",
-          line: i + 1,
-          match: m[0]
-        });
-      }
-    });
-    return dedupeByLine(findings);
-  }
-};
-
-/**
- * Token hallucination: a colour utility whose core *looks* like an Urbicon UI
- * semantic token (right namespace / intent prefix) but is not in the validated
- * whitelist. Narrow by construction — only fires on our own namespaces, so it
- * never flags `bg-transparent`, `bg-cover`, or arbitrary `bg-[#fff]`.
- */
-const tokenHallucination: Rule = {
-  id: 'token-hallucination',
-  severity: 'warning',
-  description:
-    'Colour utility referencing a non-existent semantic token (e.g. `bg-status-danger`).',
-  check(lines) {
-    const prefixAlt = COLOR_PREFIXES.join('|');
-    // capture: prefix, then the core up to a class boundary / opacity / end
-    const re = new RegExp(`\\b(${prefixAlt})-([a-z][a-z0-9-]*)(?:\\/\\d{1,3})?\\b`, 'g');
-    const findings: Finding[] = [];
-
-    lines.forEach((line, i) => {
-      for (const m of line.matchAll(re)) {
-        const core = m[2]!;
-        if (!looksSemantic(core)) continue;
-        if (VALID_TOKEN_CORES.has(core)) continue;
-
-        findings.push({
-          ruleId: this.id,
-          severity: this.severity,
-          kind: 'deterministic',
-          message: `\`${m[1]}-${core}\` is not a real token — likely hallucinated.`,
-          fix: suggestForBadCore(core),
-          line: i + 1,
-          match: m[0] // full token incl. any `/NN` opacity suffix
-        });
-      }
-    });
-    return dedupeByLine(findings);
-  }
-};
-
-/** Does this utility core sit in one of our semantic namespaces / intent families? */
-function looksSemantic(core: string): boolean {
-  // Font-size cores (`text-sm`, `text-2xl`) share the `text-` namespace but are not colour tokens.
-  if (/^text-(?:xs|sm|base|lg|\d?xl)$/.test(core)) return false;
-  if (isForeignVocab(core)) return true; // shadcn/ui vocabulary — always foreign
-  if (SEMANTIC_NAMESPACES.some((ns) => core.startsWith(ns))) return true;
-  if (core.startsWith('status-')) return true; // owned-looking, never valid → flag
-  // intent-with-suffix: `primary-muted`, `success-foo` (bare `primary` is valid and caught by the whitelist)
-  for (const intent of INTENT_PREFIXES) {
-    if (core.startsWith(`${intent}-`)) return true;
-  }
-  if (core.endsWith('-fg')) return true; // `-foreground` is already covered by isForeignVocab above
-  return false;
-}
-
-function suggestForBadCore(core: string): string {
-  // The `-foreground` family is the most common shadcn pattern — give the precise replacement first.
-  if (
-    core === 'foreground' ||
-    core.endsWith('-foreground') ||
-    core === 'fg' ||
-    core.endsWith('-fg')
-  ) {
-    return 'Use `text-on-primary` / `text-on-surface` for foreground-on-intent text, or `text-text-primary`/`-secondary` for general text.';
-  }
-  if (isForeignVocab(core)) return SHADCN_FIX;
-  for (const [bad, hint] of Object.entries(KNOWN_BAD_NAMESPACES)) {
-    if (bad.endsWith('-') ? core.startsWith(bad) : core.endsWith(bad)) return hint;
-  }
-  if (core.startsWith('surface-'))
-    return 'Valid surfaces: surface-base/quiet/subtle/elevated/overlay/hover/active/selected/inverted.';
-  if (core.startsWith('feedback-'))
-    return 'Valid feedback tokens: feedback-{info,success,warning,error}[-subtle].';
-  const intent = INTENT_NAMES.find((n) => core.startsWith(`${n}-`));
-  if (intent)
-    return `Valid \`${intent}\` variants: ${intent}, ${intent}-hover, ${intent}-active, ${intent}-subtle, ${intent}-emphasis, or a scale step ${intent}-50…${intent}-950.`;
-  return 'Check `get_css_reference()` for the exact token name.';
-}
-
-/** All deterministic rules, in report order. */
-export const RULES: Rule[] = [
-  rawTailwindColor,
-  darkModeOverride,
-  focusNotVisible,
-  hardcodedZIndex,
-  dynamicClassInterpolation,
-  tokenHallucination
-];