@af-mobile/eslint-plugin 2.0.0

package/index.js

@@ -0,0 +1,95 @@
+// AIFlow UI —— eslint-plugin-aiflow 入口（ESLint 9 flat config 兼容）
+// 20 条规则：L1(2) + L2(7) + L3(6) + L3.5(5)
+// （definePage 消费端 7 条规则已随 definePage 全局单例移除）
+import noTokenModification from './rules/no-token-modification.js';
+import noInlineStyle from './rules/no-inline-style.js';
+import tokenWhitelist from './rules/token-whitelist.js';
+import noRecipeBreak from './rules/no-recipe-break.js';
+import noVariantConflict from './rules/no-variant-conflict.js';
+import noArbitraryValue from './rules/no-arbitrary-value.js';
+import noTailwindSyntax from './rules/no-tailwind-syntax.js';
+import preferComponent from './rules/prefer-component.js';
+import atomicDuplicate from './rules/atomic-duplicate.js';
+import noRegisterAll from './rules/no-register-all.js';
+import wcLightNoStyle from './rules/wc-light-no-style.js';
+import wcShadowUseToken from './rules/wc-shadow-use-token.js';
+import wcPartNaming from './rules/wc-part-naming.js';
+import wcEventNaming from './rules/wc-event-naming.js';
+import wcAriaRequired from './rules/wc-aria-required.js';
+import wcCleanup from './rules/wc-cleanup.js';
+import wcBlockNoInternalRef from './rules/wc-block-no-internal-ref.js';
+import wcBlockPropsCount from './rules/wc-block-props-count.js';
+import wcBlockStates from './rules/wc-block-states.js';
+import wcBlockVariantEnum from './rules/wc-block-variant-enum.js';
+
+const plugin = {
+  meta: { name: 'eslint-plugin-aiflow', version: '2.0.0' },
+  rules: {
+    // L1（2 条，全部 error；tokens-css-locked 由 CODEOWNERS + 分支保护，非 ESLint 规则）
+    'no-token-modification': noTokenModification,
+    'no-inline-style': noInlineStyle,
+    // L1-3 tokens-css-locked 是 CODEOWNERS + 分支保护，非 ESLint 规则
+    // L2（7 条：4 error + 3 warn）
+    'token-whitelist': tokenWhitelist,
+    'no-recipe-break': noRecipeBreak,
+    'no-variant-conflict': noVariantConflict,
+    'no-arbitrary-value': noArbitraryValue,
+    'no-tailwind-syntax': noTailwindSyntax,
+    'prefer-component': preferComponent,
+    'atomic-duplicate': atomicDuplicate,
+    // L3（6 条：4 error + 2 warn）
+    'wc-light-no-style': wcLightNoStyle,
+    'wc-shadow-use-token': wcShadowUseToken,
+    'wc-part-naming': wcPartNaming,
+    'wc-event-naming': wcEventNaming,
+    'wc-aria-required': wcAriaRequired,
+    'wc-cleanup': wcCleanup,
+    // L3.5（5 条：Block 层约束 + register 引导）
+    'no-register-all': noRegisterAll,
+    'wc-block-no-internal-ref': wcBlockNoInternalRef,
+    'wc-block-props-count': wcBlockPropsCount,
+    'wc-block-states': wcBlockStates,
+    'wc-block-variant-enum': wcBlockVariantEnum,
+  },
+  configs: {},
+};
+
+// recommended 配置：按设计文档 L4 §3.2-3.4 的 severity 启用
+Object.assign(plugin.configs, {
+  recommended: {
+    plugins: { aiflow: plugin },
+    rules: {
+      // L1 error
+      'aiflow/no-token-modification': 'error',
+      'aiflow/no-inline-style': 'error',
+      // L2 error
+      // extraComponents: af-data 属 L3.5 Block 层数据源元素（非 L3 注册组件，不在 whitelist-v1.json），
+      // 但 AI 生成的页面代码（createPage/:bind 体系）需要能使用 <af-data>，故在规则级放行
+      'aiflow/token-whitelist': ['error', { extraComponents: ['af-data'] }],
+      'aiflow/no-recipe-break': 'error',
+      'aiflow/no-arbitrary-value': 'error',
+      'aiflow/no-tailwind-syntax': 'error',
+      // L2 warn
+      'aiflow/no-variant-conflict': 'warn',
+      'aiflow/prefer-component': 'warn',
+      'aiflow/atomic-duplicate': 'warn',
+      // L3 error
+      'aiflow/wc-light-no-style': 'error',
+      'aiflow/wc-shadow-use-token': 'error',
+      'aiflow/wc-event-naming': 'error',
+      'aiflow/wc-aria-required': 'error',
+      // L3 warn
+      'aiflow/wc-part-naming': 'warn',
+      'aiflow/wc-cleanup': 'warn',
+      // L3.5 error（Block 层约束）
+      'aiflow/wc-block-no-internal-ref': 'error',
+      'aiflow/wc-block-props-count': 'error',
+      'aiflow/wc-block-states': 'error',
+      // L3.5 warn（引导性/启发式）
+      'aiflow/no-register-all': 'warn',
+      'aiflow/wc-block-variant-enum': 'warn',
+    },
+  },
+});
+
+export default plugin;

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@af-mobile/eslint-plugin",
+  "version": "2.0.0",
+  "description": "AIFlow UI ESLint plugin — 27 rules (L1/L2/L3/L3.5) enforcing design-system + Web Component constraints",
+  "type": "module",
+  "main": "./index.js",
+  "module": "./index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "rules/",
+    "utils/"
+  ],
+  "dependencies": {
+    "postcss": "^8.4.0"
+  },
+  "peerDependencies": {
+    "eslint": ">=9.0.0"
+  },
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "web-components",
+    "design-system",
+    "aiflow"
+  ],
+  "license": "MIT"
+}

package/rules/atomic-duplicate.js

@@ -0,0 +1,60 @@
+// L2-7 aiflow/atomic-duplicate（warn，可自动修）
+// 检测：同一 class 属性内出现两个同属性原子（如 p-4 p-2），保留最后一个
+import { extractAllClassLists } from '../utils/helpers.js';
+
+// 属性前缀映射：p-* → padding, m-* → margin, t-* → font-size, r-* → border-radius
+function getPropPrefix(cls) {
+  const m = cls.match(/^([pmtr])-(.+)$/);
+  return m ? m[1] : null;
+}
+
+const PROP_LABELS = { p: 'padding', m: 'margin', t: 'font-size', r: 'border-radius' };
+
+export default {
+  meta: {
+    type: 'suggestion',
+    docs: { description: '检测同属性原子类重复，保留最后一个' },
+    schema: [],
+    messages: {
+      duplicate: "Duplicate {{prop}}: '{{a}}' is overwritten by '{{b}}'. Keep only '{{b}}'",
+    },
+    fixable: 'code',
+  },
+  create(context) {
+    function checkClasses(classes, node, raw) {
+      const seen = new Map(); // prefix → { cls, index }
+      for (let i = 0; i < classes.length; i++) {
+        const cls = classes[i];
+        const prefix = getPropPrefix(cls);
+        if (!prefix) continue;
+        if (seen.has(prefix)) {
+          const prev = seen.get(prefix);
+          context.report({
+            node,
+            messageId: 'duplicate',
+            data: { prop: PROP_LABELS[prefix] || prefix, a: prev.cls, b: cls },
+            fix(fixer) {
+              const sourceCode = context.sourceCode || context.getSourceCode();
+              const text = sourceCode.getText(node);
+              const idx = text.indexOf(raw);
+              if (idx < 0) return null;
+              const classIdx = idx + raw.indexOf(prev.cls);
+              const before = text.slice(0, classIdx);
+              const after = text.slice(classIdx + prev.cls.length);
+              const trimmedBefore = before.replace(/\s+$/, '');
+              return fixer.replaceText(node, trimmedBefore + after);
+            },
+          });
+        }
+        seen.set(prefix, { cls, index: i });
+      }
+    }
+    function checkString(str, node) {
+      for (const { classes, raw } of extractAllClassLists(str)) checkClasses(classes, node, raw);
+    }
+    return {
+      Literal(node) { if (typeof node.value === 'string') checkString(node.value, node); },
+      TemplateElement(node) { if (node.value?.raw) checkString(node.value.raw, node); },
+    };
+  },
+};

package/rules/no-arbitrary-value.js

@@ -0,0 +1,52 @@
+// L2-4 aiflow/no-arbitrary-value（error，部分可自动修）
+// 检测：class 含 [xxx] 任意值语法 / 档位越界（如 p-7）
+import { extractAllClassLists, ALL_CLASSES } from '../utils/helpers.js';
+
+// 合法档位
+const RANGES = {
+  'p': ['0', '1', '2', '3', '4', '5', '6', '8', '10'],
+  'm': ['0', '1', '2', '3', '4', '5', '6'],
+  't': ['xs', 'sm', 'md', 'lg', 'xl'],
+  'r': ['s', 'm', 'l', 'f'],
+};
+
+export default {
+  meta: {
+    type: 'problem',
+    docs: { description: '禁止任意值语法和档位越界' },
+    schema: [],
+    messages: {
+      arbitrary: "'{{name}}' arbitrary value syntax forbidden; use closest atomic or extend recipes.project.css",
+      outOfRange: "'{{name}}' out of range ({{valid}}); use closest atomic",
+    },
+  },
+  create(context) {
+    function checkClass(cls, node) {
+      // 白名单内的 class 直接放行（如 t-center/t-b 是合法原子类，非档位）
+      if (ALL_CLASSES.has(cls)) return;
+      // [xxx] 任意值
+      if (/[\[\]]/.test(cls)) {
+        context.report({ node, messageId: 'arbitrary', data: { name: cls } });
+        return;
+      }
+      // 档位越界：前缀-档位
+      const m = cls.match(/^([pmtr])-(.+)$/);
+      if (m) {
+        const [, prefix, val] = m;
+        const valid = RANGES[prefix.toUpperCase()] || RANGES[prefix];
+        if (valid && !valid.includes(val)) {
+          context.report({ node, messageId: 'outOfRange', data: { name: cls, valid: valid.join('/') } });
+        }
+      }
+    }
+    function checkString(str, node) {
+      for (const { classes } of extractAllClassLists(str)) {
+        for (const cls of classes) checkClass(cls, node);
+      }
+    }
+    return {
+      Literal(node) { if (typeof node.value === 'string') checkString(node.value, node); },
+      TemplateElement(node) { if (node.value?.raw) checkString(node.value.raw, node); },
+    };
+  },
+};

package/rules/no-inline-style.js

@@ -0,0 +1,127 @@
+// L1-2 aiflow/no-inline-style（error，部分可自动修）
+// 检测：style="" 中设置 forbiddenInlineStyle 列表内的属性
+// 例外：display/transform/z-index/width/height 等布局属性放行；skeleton class 元素内 width/height 放行
+// 适用：HTML/JS 文件中所有字符串字面量（含 template literal），覆盖组件 innerHTML 赋值场景
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { resolve, dirname } from 'node:path';
+
+// 加载 whitelist（与规则文件同级目录 ../utils/whitelist-v1.json）
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const whitelistPath = resolve(__dirname, '../utils/whitelist-v1.json');
+const whitelist = JSON.parse(readFileSync(whitelistPath, 'utf8'));
+const FORBIDDEN = new Set(whitelist.forbiddenInlineStyle);
+
+// 布局类属性放行（设计文档 L1-2 例外）
+const ALLOWED_LAYOUT = new Set([
+  'display', 'transform', 'z-index', 'width', 'height',
+  'position', 'top', 'right', 'bottom', 'left',
+  'flex', 'flex-direction', 'flex-wrap', 'justify-content', 'align-items',
+  'grid-template-columns', 'grid-template-rows', 'gap',
+  'overflow', 'overflow-x', 'overflow-y',
+]);
+
+// 提取 style="..." 内容中的属性名
+function extractStyleProps(styleContent) {
+  const props = [];
+  // 匹配 prop-name: value; 形式
+  const re = /([a-z-]+)\s*:/g;
+  let m;
+  while ((m = re.exec(styleContent))) props.push(m[1].toLowerCase());
+  return props;
+}
+
+// 检测 style="" 字符串中的 forbidden 属性
+function checkStyleString(str) {
+  const violations = [];
+  const styleRe = /style\s*=\s*"([^"]*)"/g;
+  let m;
+  while ((m = styleRe.exec(str))) {
+    const styleContent = m[1];
+    const props = extractStyleProps(styleContent);
+    for (const prop of props) {
+      if (FORBIDDEN.has(prop)) {
+        violations.push({ prop, value: styleContent });
+      }
+    }
+  }
+  return violations;
+}
+
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: '禁止 inline style 中使用 forbidden 属性（应使用 L2 class）',
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        allowProperties: {
+          type: 'array',
+          items: { type: 'string' },
+          description: '项目级额外放行的属性名',
+        },
+      },
+      additionalProperties: false,
+    }],
+    messages: {
+      forbidden: "Inline style '{{value}}' is forbidden. Use class instead",
+    },
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    const extraAllow = new Set(options.allowProperties || []);
+
+    return {
+      // 检测字符串字面量（含 template literal）
+      Literal(node) {
+        if (typeof node.value !== 'string') return;
+        const violations = checkStyleString(node.value);
+        for (const v of violations) {
+          if (extraAllow.has(v.prop)) continue;
+          context.report({ node, messageId: 'forbidden', data: { value: v.value } });
+        }
+      },
+      TemplateElement(node) {
+        if (!node.value || !node.value.raw) return;
+        const violations = checkStyleString(node.value.raw);
+        for (const v of violations) {
+          if (extraAllow.has(v.prop)) continue;
+          context.report({ node, messageId: 'forbidden', data: { value: v.value } });
+        }
+      },
+      // 检测 el.style.setProperty('color', ...) / el.style.xxx = '...' 绕过
+      // 仅当属性名为 forbidden 视觉属性且非常量 --* CSS 变量时报告
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee?.type !== 'MemberExpression') return;
+        if (callee.object?.type !== 'MemberExpression') return;
+        if (callee.object.property?.name !== 'style') return;
+        if (callee.property?.name !== 'setProperty') return;
+        const propArg = node.arguments?.[0];
+        if (!propArg || propArg.type !== 'Literal' || typeof propArg.value !== 'string') return;
+        // CSS 自定义属性（--*）豁免：用于主题变量传递，由 no-token-modification 规则单独管
+        if (propArg.value.startsWith('--')) return;
+        const prop = propArg.value.toLowerCase();
+        if (FORBIDDEN.has(prop) && !ALLOWED_LAYOUT.has(prop) && !extraAllow.has(prop)) {
+          context.report({ node, messageId: 'forbidden', data: { value: `${prop}` } });
+        }
+      },
+      AssignmentExpression(node) {
+        // el.style.color = 'red' 形式
+        if (node.left?.type !== 'MemberExpression') return;
+        if (node.left.object?.type !== 'MemberExpression') return;
+        if (node.left.object.property?.name !== 'style') return;
+        const propName = node.left.property?.name;
+        if (!propName) return;
+        // kebab-case 转换：backgroundColor → background-color
+        const kebab = propName.replace(/[A-Z]/g, m => '-' + m.toLowerCase());
+        if (FORBIDDEN.has(kebab) && !ALLOWED_LAYOUT.has(kebab) && !extraAllow.has(kebab)) {
+          context.report({ node, messageId: 'forbidden', data: { value: kebab } });
+        }
+      },
+    };
+  },
+};

package/rules/no-recipe-break.js

@@ -0,0 +1,52 @@
+// L2-2 aiflow/no-recipe-break（error，3 子规则）
+// a: .cell + f/fc 原子 → 布局冲突
+// b: .btn（非 .btn-ghost）+ text-brand/text-danger/text-success → 对比度问题
+// c: .input + t-sm/t-xs → iOS 焦点缩放
+import { extractAllClassLists } from '../utils/helpers.js';
+
+const FLEX_ATOMS = new Set(['f', 'fc']);
+const COLORED_TEXT = new Set(['text-brand', 'text-danger', 'text-success']);
+const SMALL_FONT = new Set(['t-sm', 't-xs']);
+
+export default {
+  meta: {
+    type: 'problem',
+    docs: { description: '禁止原子类破坏 recipe 内置样式' },
+    schema: [],
+    messages: {
+      cellFlex: ".cell has built-in display:flex, adding 'f'/'fc' may break layout",
+      btnColor: ".btn background uses --c-brand, text color must keep --c-onbrand contrast. Use .btn-ghost instead for colored text",
+      inputFont: ".input font-size must be 16px (--t-md) to prevent iOS focus zoom. Put help text in <label> or .form-err instead",
+    },
+  },
+  create(context) {
+    function checkClasses(classes, node) {
+      const set = new Set(classes);
+      // a: .cell + f/fc
+      if (set.has('cell')) {
+        for (const a of FLEX_ATOMS) {
+          if (set.has(a)) { context.report({ node, messageId: 'cellFlex' }); break; }
+        }
+      }
+      // b: .btn（非 .btn-ghost）+ colored text
+      if (set.has('btn') && !set.has('btn-ghost')) {
+        for (const a of COLORED_TEXT) {
+          if (set.has(a)) { context.report({ node, messageId: 'btnColor' }); break; }
+        }
+      }
+      // c: .input + t-sm/t-xs
+      if (set.has('input')) {
+        for (const a of SMALL_FONT) {
+          if (set.has(a)) { context.report({ node, messageId: 'inputFont' }); break; }
+        }
+      }
+    }
+    function checkString(str, node) {
+      for (const { classes } of extractAllClassLists(str)) checkClasses(classes, node);
+    }
+    return {
+      Literal(node) { if (typeof node.value === 'string') checkString(node.value, node); },
+      TemplateElement(node) { if (node.value?.raw) checkString(node.value.raw, node); },
+    };
+  },
+};

package/rules/no-register-all.js

@@ -0,0 +1,29 @@
+// L3 aiflow/no-register-all（error）
+// 检测：registerAll() 调用（已废弃，诱导全量加载，失去 Tree Shaking）
+// 正确：register('af-list', 'af-dialog') 显式列名，配合 Tree Shaking 按需打包
+export default {
+  meta: {
+    type: 'problem',
+    docs: { description: '禁止 registerAll()，改用 register(...names) 显式列名', fixable: 'ai-rewrite' },
+    schema: [],
+    messages: {
+      registerAll: "registerAll() 已废弃（诱导全量加载，失去 Tree Shaking），改用 register(...names) 显式列名",
+    },
+  },
+  create(context) {
+    const filename = context.filename || context.getFilename();
+    // 非消费端放行：库源码（index.js 导出 registerAll）/单元测试/构建脚本（build.mjs 全量入口）
+    if (/src[\\/]|test[\\/]|scripts[\\/]/.test(filename)) return {};
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        const name = callee.type === 'Identifier' ? callee.name
+          : callee.type === 'MemberExpression' && callee.property.type === 'Identifier' ? callee.property.name
+            : null;
+        if (name === 'registerAll') {
+          context.report({ node, messageId: 'registerAll' });
+        }
+      },
+    };
+  },
+};

package/rules/no-tailwind-syntax.js

@@ -0,0 +1,31 @@
+// L2-5 aiflow/no-tailwind-syntax（error）
+// 检测：class 含 sm:/md:/lg:/xl:/hover:/focus:/active:/dark: 前缀
+import { extractAllClassLists } from '../utils/helpers.js';
+
+const TAILWIND_PREFIX = /^(sm|md|lg|xl|hover|focus|active|dark):/;
+
+export default {
+  meta: {
+    type: 'problem',
+    docs: { description: '禁止 Tailwind 响应式/状态前缀语法' },
+    schema: [],
+    messages: {
+      tailwind: "'{{name}}' responsive/state prefix syntax forbidden. Use @container in recipes.project.css for container-queries responsive behavior",
+    },
+  },
+  create(context) {
+    function checkString(str, node) {
+      for (const { classes } of extractAllClassLists(str)) {
+        for (const cls of classes) {
+          if (TAILWIND_PREFIX.test(cls)) {
+            context.report({ node, messageId: 'tailwind', data: { name: cls } });
+          }
+        }
+      }
+    }
+    return {
+      Literal(node) { if (typeof node.value === 'string') checkString(node.value, node); },
+      TemplateElement(node) { if (node.value?.raw) checkString(node.value.raw, node); },
+    };
+  },
+};

package/rules/no-token-modification.js

@@ -0,0 +1,92 @@
+// L1-1 aiflow/no-token-modification（error）
+// 检测：非 tokens.css / tokens.project.css 文件内，重定义 --(c|s|r|t|lh|fw|shadow|z|ease|dur)-* 变量
+// 例外：路径匹配 **/tokens.css 或 **/tokens.project.css
+import postcss from 'postcss';
+
+const TOKEN_PREFIX_RE = /^--(c|s|r|t|lh|fw|shadow|z|ease|dur)-/;
+
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: '禁止在 tokens.css 之外修改/重定义设计 token 变量',
+    },
+    schema: [],
+    messages: {
+      locked: "Token variable '{{name}}' is locked. Modify tokens.css or register in tokens.project.css instead",
+    },
+  },
+
+  create(context) {
+    const filename = context.filename || context.getFilename();
+    // 例外文件：tokens.css 和 tokens.project.css
+    if (/tokens(\.project)?\.css$/.test(filename)) return {};
+
+    return {
+      // ESLint 9 对 .css 文件原生支持不足，用源码文本直接喂 postcss
+      Program(node) {
+        const source = context.sourceCode || context.getSourceCode();
+        const css = source.getText();
+        if (!css.includes('--')) return;
+        try {
+          const root = postcss.parse(css);
+          root.walkDecls(decl => {
+            if (TOKEN_PREFIX_RE.test(decl.prop)) {
+              context.report({
+                node,
+                loc: {
+                  // postcss 节点有 source.start/end（行从 1 起，列从 0 起 → ESLint 期望 0 起）
+                  start: { line: decl.source.start.line, column: decl.source.start.column - 1 },
+                  end: { line: decl.source.end.line, column: decl.source.end.column },
+                },
+                messageId: 'locked',
+                data: { name: decl.prop },
+              });
+            }
+          });
+        } catch {
+          // 非 CSS 内容（如 .js 文件恰好进入此规则）：静默跳过
+        }
+      },
+      // 检测 JS 内 el.style.setProperty('--c-brand', ...) / removeProperty('--c-brand') 间接覆盖 token
+      // 也覆盖 el.style['--c-brand'] = ... 形式
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee?.type !== 'MemberExpression') return;
+        if (callee.object?.type !== 'MemberExpression') return;
+        if (callee.object.property?.name !== 'style') return;
+        const method = callee.property?.name;
+        if (method !== 'setProperty' && method !== 'removeProperty') return;
+        const propArg = node.arguments?.[0];
+        if (!propArg || propArg.type !== 'Literal' || typeof propArg.value !== 'string') return;
+        if (TOKEN_PREFIX_RE.test(propArg.value)) {
+          context.report({ node, messageId: 'locked', data: { name: propArg.value } });
+        }
+      },
+      AssignmentExpression(node) {
+        // el.style['--c-brand'] = ... 或 el.style.cssText = '--c-brand: ...'
+        if (node.left?.type !== 'MemberExpression') return;
+        if (node.left.object?.type !== 'MemberExpression') return;
+        if (node.left.object.property?.name !== 'style') return;
+        // 计算属性访问 el.style['--c-brand']
+        const propNode = node.left.property;
+        if (propNode?.type === 'Literal' && typeof propNode.value === 'string'
+            && TOKEN_PREFIX_RE.test(propNode.value)) {
+          context.report({ node, messageId: 'locked', data: { name: propNode.value } });
+        }
+        // el.style.cssText = '--c-brand: red; ...' 间接覆盖
+        if (propNode?.type === 'Identifier' && propNode.name === 'cssText') {
+          const valNode = node.right;
+          if (valNode?.type === 'Literal' && typeof valNode.value === 'string') {
+            const matches = valNode.value.match(/--[a-z][\w-]*/g) || [];
+            for (const m of matches) {
+              if (TOKEN_PREFIX_RE.test(m)) {
+                context.report({ node, messageId: 'locked', data: { name: m } });
+              }
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/rules/no-variant-conflict.js

@@ -0,0 +1,70 @@
+// L2-3 aiflow/no-variant-conflict（warn，可自动修）
+// 检测：同属性互斥变体对同时出现，自动修：保留最后一个
+import { extractAllClassLists } from '../utils/helpers.js';
+
+// 互斥变体组：同组内只能出现一个
+const CONFLICT_GROUPS = [
+  ['btn-sm', 'btn-lg'],
+  ['tag-ok', 'tag-warn', 'tag-danger'],
+  // 圆角类
+  ['r-s', 'r-m', 'r-l', 'r-f'],
+  // padding 类
+  ['p-0', 'p-1', 'p-2', 'p-3', 'p-4', 'p-5', 'p-6', 'p-8', 'p-10'],
+];
+
+export default {
+  meta: {
+    type: 'suggestion',
+    docs: { description: '检测互斥变体冲突，保留最后一个' },
+    schema: [],
+    messages: {
+      conflict: "Variant conflict: '{{a}}' and '{{b}}' — only the later one takes effect, remove the earlier one",
+    },
+    fixable: 'code',
+  },
+  create(context) {
+    function checkClasses(classes, node, raw, offset) {
+      for (const group of CONFLICT_GROUPS) {
+        const found = [];
+        for (const cls of classes) {
+          if (group.includes(cls)) found.push(cls);
+        }
+        if (found.length < 2) continue;
+        // 保留最后一个，删除前面的
+        const keep = found[found.length - 1];
+        const remove = found.slice(0, -1);
+        for (const r of remove) {
+          context.report({
+            node,
+            messageId: 'conflict',
+            data: { a: r, b: keep },
+            fix(fixer) {
+              // 删除 class 名（含前导空格）
+              const sourceCode = context.sourceCode || context.getSourceCode();
+              const text = sourceCode.getText(node);
+              const idx = text.indexOf(raw);
+              if (idx < 0) return null;
+              const classIdx = idx + raw.indexOf(r);
+              // 删除 " r" 或 "r " 或 "r"
+              const before = text.slice(0, classIdx);
+              const after = text.slice(classIdx + r.length);
+              // 如果前面有空格，连空格一起删
+              const trimmedBefore = before.replace(/\s+$/, '');
+              const newText = trimmedBefore + after;
+              return fixer.replaceText(node, newText);
+            },
+          });
+        }
+      }
+    }
+    function checkString(str, node) {
+      for (const { classes, raw, offset } of extractAllClassLists(str)) {
+        checkClasses(classes, node, raw, offset);
+      }
+    }
+    return {
+      Literal(node) { if (typeof node.value === 'string') checkString(node.value, node); },
+      TemplateElement(node) { if (node.value?.raw) checkString(node.value.raw, node); },
+    };
+  },
+};