@mocoto/mahoraga 0.14.1 → 0.14.3

package/dist/analysts/tailwind/analysts/analyst-tailwind.js

@@ -3,8 +3,28 @@ import { messages } from '../../../core/messages/index.js';
 import { createLineLookup } from '../../../shared/helpers/index.js';
 import { criarAnalista, criarOcorrencia } from '../../../types/index.js';
 const disableEnv = process.env.SUKUNA_DISABLE_PLUGIN_TAILWIND === '1';
+const V3_TO_V4_CLASS_RENAME = {
+    'shadow-sm': 'shadow-xs',
+    'drop-shadow-sm': 'drop-shadow-xs',
+    'blur-sm': 'blur-xs',
+    'backdrop-blur-sm': 'backdrop-blur-xs',
+    'rounded-sm': 'rounded-xs',
+    'outline-none': 'outline-hidden',
+    'flex-shrink': 'shrink',
+    'flex-grow': 'grow',
+    'overflow-ellipsis': 'text-ellipsis',
+    'decoration-slice': 'box-decoration-slice',
+    'decoration-clone': 'box-decoration-clone',
+};
+const V3_TO_V4_SUFFIX_RENAME = {
+    'shadow': 'shadow-sm',
+    'drop-shadow': 'drop-shadow-sm',
+    'blur': 'blur-sm',
+    'backdrop-blur': 'backdrop-blur-sm',
+    'rounded': 'rounded-sm',
+    'ring': 'ring-3',
+};
 function extractBalancedBraces(src, braceStartIndex, maxLen = 8000) {
-    // braceStartIndex deve apontar para '{'
     if (braceStartIndex < 0 || braceStartIndex >= src.length) {
         return null;
     }
@@ -26,7 +46,6 @@ function extractBalancedBraces(src, braceStartIndex, maxLen = 8000) {
             continue;
         }
         if (ch === '\\') {
-            // escape dentro de strings
             if (inSingle || inDouble || inBacktick) {
                 escaped = true;
             }
@@ -48,8 +67,6 @@ function extractBalancedBraces(src, braceStartIndex, maxLen = 8000) {
             continue;
         }
         if (inBacktick) {
-            // Nota: ignoramos completamente conteúdo de template literal
-            // para não quebrar em '}' de interpolações `${...}`.
             if (ch === '`') {
                 inBacktick = false;
             }
@@ -85,27 +102,24 @@ function extractBalancedBraces(src, braceStartIndex, maxLen = 8000) {
     return null;
 }
 function sanitizeTemplateLiteralText(text) {
-    // Remove interpolações `${...}` para manter apenas a parte estática.
     return text.replace(/\$\{[\s\S]*?\}/g, ' ');
 }
 function normalizeClassText(text) {
     return (text || '').replace(/\s+/g, ' ').trim();
 }
 function isTernaryExpressionText(text) {
-    // Heurística: se há um '?' e ':' no trecho do atributo, trate como branches exclusivas.
-    // Isso reduz falsos positivos de conflito entre classes mutuamente exclusivas.
     return /\?/.test(text) && /:/.test(text);
 }
 function extractStringLiterals(text) {
     const out = [];
     for (const metrica of text.matchAll(/"([^"\\\n]|\\.)*"/g)) {
-        out.push((metrica[0] ?? '').slice(1, -1));
+        out.push(metrica[0].slice(1, -1));
     }
     for (const metrica of text.matchAll(/'([^'\\\n]|\\.)*'/g)) {
-        out.push((metrica[0] ?? '').slice(1, -1));
+        out.push(metrica[0].slice(1, -1));
     }
     for (const metrica of text.matchAll(/`([^`]*)`/g)) {
-        out.push(sanitizeTemplateLiteralText((metrica[1] ?? '')));
+        out.push(sanitizeTemplateLiteralText(metrica[1]));
     }
     return out;
 }
@@ -128,30 +142,24 @@ function extractClassBlocks(src) {
             line
         });
     };
-    // HTML/JSX: class="..." / className="..." (string literal)
     for (const metrica of src.matchAll(/\bclass(Name)?\s*=\s*(["'])([^"']*)\2/gi)) {
-        pushBlock(metrica[3] ?? '', lineOf(metrica.index));
+        pushBlock(metrica[3], lineOf(metrica.index));
     }
-    // JSX: className={"..."} / className={'...'}
     for (const metrica of src.matchAll(/\bclass(Name)?\s*=\s*\{\s*(["'])([^"']*)\2\s*\}/gi)) {
-        pushBlock(metrica[3] ?? '', lineOf(metrica.index));
+        pushBlock(metrica[3], lineOf(metrica.index));
     }
-    // JSX: className={`...${...}...`} (template literal)
     for (const metrica of src.matchAll(/\bclass(Name)?\s*=\s*\{\s*`([^`]*)`\s*\}/gi)) {
-        pushBlock(sanitizeTemplateLiteralText(metrica[2] ?? ''), lineOf(metrica.index));
+        pushBlock(sanitizeTemplateLiteralText(metrica[2]), lineOf(metrica.index));
     }
-    // JS: const x = `...` (casos raros, mas evita perder HTML em strings)
     for (const metrica of src.matchAll(/\bclass(Name)?\s*=\s*`([^`]*)`/gi)) {
-        pushBlock(sanitizeTemplateLiteralText(metrica[2] ?? ''), lineOf(metrica.index));
+        pushBlock(sanitizeTemplateLiteralText(metrica[2]), lineOf(metrica.index));
     }
-    // JSX: className={...} (expressões comuns: ternário, arrays/join, concat, cn(...), etc)
-    // Mais robusto que regex simples: captura expressão com chaves balanceadas.
     for (const metrica of src.matchAll(/\bclass(Name)?\s*=\s*\{/gi)) {
-        const idx = metrica.index ?? -1;
+        const idx = metrica.index;
         if (idx < 0) {
             continue;
         }
-        const braceIdx = idx + (metrica[0].length ?? 0) - 1;
+        const braceIdx = idx + metrica[0].length - 1;
         const expr = extractBalancedBraces(src, braceIdx);
         if (!expr) {
             continue;
@@ -167,13 +175,12 @@ function extractClassBlocks(src) {
         }
         pushBlock(literals.join(' '), line);
     }
-    // Astro: class:list={...}
     for (const metrica of src.matchAll(/\bclass:list\s*=\s*\{/gi)) {
-        const idx = metrica.index ?? -1;
+        const idx = metrica.index;
         if (idx < 0) {
             continue;
         }
-        const braceIdx = idx + (metrica[0].length ?? 0) - 1;
+        const braceIdx = idx + metrica[0].length - 1;
         const expr = extractBalancedBraces(src, braceIdx);
         if (!expr) {
             continue;
@@ -189,10 +196,8 @@ function extractClassBlocks(src) {
         }
         pushBlock(literals.join(' '), line);
     }
-    // JSX/TS: helpers comuns (clsx/cn/twMerge/classNames/classnames)
-    // Heurística simples (sem parser): extrai literais de string dentro da chamada.
     for (const metrica of src.matchAll(/\b(?:clsx|cn|twMerge|classNames|classnames)\s*\(([^)]*)\)/g)) {
-        const args = metrica[1] ?? '';
+        const args = metrica[1];
         const literals = extractStringLiterals(args).map(string => string.trim()).filter(Boolean);
         if (!literals.length) {
             continue;
@@ -206,7 +211,7 @@ function hasTailwindTokens(src) {
     if (!blocks.length) {
         return false;
     }
-    const tokenRe = /\b(?:bg-|text-|m[trblxy]?-|p[trblxy]?-|flex|grid|gap-|space-|rounded|shadow|justify-|items-|w-|h-|min-w-|max-w-|min-h-|max-h-|inset-|top-|left-|right-|bottom-|z-|overflow-|cursor-|select-|border|ring|opacity-|font-|leading-|tracking-|transition|duration-|ease-|animate-|underline|no-underline|sr-only|not-sr-only|container)\S*/i;
+    const tokenRe = /\b(?:bg-|text-|m[trblxy]?-|p[trblxy]?-|flex|grid|gap-|space-|rounded|shadow|justify-|items-|w-|h-|min-w-|max-w-|min-h-|max-h-|inset-|top-|left-|right-|bottom-|z-|overflow-|cursor-|select-|border|ring|opacity-|font-|leading-|tracking-|transition|duration-|ease-|animate-|underline|no-underline|sr-only|not-sr-only|container|field-sizing-|text-shadow-|inset-shadow-|zoom-|perspective-|outline-|drop-shadow-|backdrop-blur-)\S*/i;
     return blocks.some(base => tokenRe.test(base.text));
 }
 function extractClasses(src) {
@@ -234,14 +239,10 @@ function splitVariants(token) {
     };
 }
 function propertyKey(token) {
-    // Respeita variantes (sm:, md:, dark:, hover:, etc.): conflitos só contam
-    // dentro do mesmo "contexto" de variantes.
     const { variants, base } = splitVariants(token);
-    // ícones/fontawesome ou tokens livres não são tratados como conflito
     if (/^(fa-|icon-)/.test(base)) {
         return null;
     }
-    // padding/margin: não trate px + py como conflito (são eixos diferentes)
     const padMatch = /^(p[trblxy]?)(?:-|\[)/.exec(base);
     if (padMatch) {
         return `${variants}|padding:${padMatch[1]}`;
@@ -257,35 +258,27 @@ function propertyKey(token) {
     if (/^space-[xy]/.test(base)) {
         return `${variants}|space`;
     }
-    // display
     if (/^(block|inline-block|inline|flex|grid|hidden)$/.test(base)) {
         return `${variants}|display`;
     }
-    // flex direction
     if (/^flex-(row|col)(-reverse)?$/.test(base)) {
         return `${variants}|flex-direction`;
     }
-    // align/justify
     if (/^justify-/.test(base)) {
         return `${variants}|justify`;
     }
     if (/^items-/.test(base)) {
         return `${variants}|items`;
     }
-    // border radius
     if (/^rounded(?:-|\b|\[)/.test(base)) {
         return `${variants}|rounded`;
     }
-    // shadow: distinguir tamanho vs cor para permitir combinações legítimas
     if (/^shadow(?:-|\b|\[)/.test(base)) {
-        // shadow, shadow-sm, shadow-md, shadow-lg, shadow-xl, shadow-2xl, shadow-inner, shadow-none
         if (/^shadow(?:-sm|-md|-lg|-xl|-2xl|-inner|-none)?$/.test(base)) {
             return `${variants}|shadow-size`;
         }
-        // shadow-[custom] ou shadow-color-shade (ex: shadow-black/20, shadow-gray-500)
         return `${variants}|shadow-color`;
     }
-    // background + text (separa tamanho vs cor para reduzir ruído)
     if (/^bg-(?!opacity-)/.test(base)) {
         return `${variants}|bg-color`;
     }
@@ -319,8 +312,23 @@ function propertyKey(token) {
         }, {
             re: /^(top|left|right|bottom)(?:-|\[)/,
             key: 'position'
+        }, {
+            re: /^field-sizing(?:-|\[)/,
+            key: 'field-sizing'
+        }, {
+            re: /^text-shadow(?:-|\[)/,
+            key: 'text-shadow'
+        }, {
+            re: /^inset-shadow(?:-|\[)/,
+            key: 'inset-shadow'
+        }, {
+            re: /^zoom(?:-|\[)/,
+            key: 'zoom'
+        }, {
+            re: /^perspective(?:-|\[)/,
+            key: 'perspective'
         }];
-    const found = groups.find(grupo => grupo.re.test(base));
+    const found = groups?.find(grupo => grupo.re.test(base));
     return found ? `${variants}|${found.key}` : null;
 }
 function warn(message, relPath, line, nivel = messages.SeverityNiveis.warning) {
@@ -335,8 +343,6 @@ function warn(message, relPath, line, nivel = messages.SeverityNiveis.warning) {
 }
 function collectTailwindIssues(src, relPath) {
     const ocorrencias = [];
-    // Importante: conflitos devem ser detectados por bloco de classes
-    // (cada atributo class/className) e não no arquivo inteiro.
     const blocks = extractClassBlocks(src);
     for (const block of blocks) {
         const tokens = (block.text || '').split(/\s+/).filter(Boolean);
@@ -346,28 +352,38 @@ function collectTailwindIssues(src, relPath) {
         const line = block.line;
         const seen = {};
         for (const token of tokens) {
+            const v4Rename = V3_TO_V4_CLASS_RENAME[token];
+            if (v4Rename) {
+                ocorrencias.push(warn(`Classe obsoleta do v3: "${token}" → use "${v4Rename}"`, relPath, line));
+                continue;
+            }
+            const baseClass = token.split(':').pop() ?? token;
+            const v4Suffix = V3_TO_V4_SUFFIX_RENAME[baseClass];
+            if (v4Suffix && baseClass === token) {
+                ocorrencias.push(warn(`Classe renomeada no v4: "${token}" → use "${v4Suffix}"`, relPath, line));
+                continue;
+            }
+            if (token.startsWith('!')) {
+                ocorrencias.push(warn(`!important como prefixo (v3) em "${token}" → mova ! para o final (ex: "${token.slice(1)}!")`, relPath, line));
+            }
             const key = propertyKey(token);
             if (!key) {
                 continue;
             }
-            if (!seen[key]) {
+            if (!(key in seen)) {
                 seen[key] = [];
             }
             seen[key].push(token);
         }
         for (const [key, list] of Object.entries(seen)) {
             const uniqTokens = [...new Set(list)];
-            // Detect duplicated exact tokens within same block (redundant classes)
             const repeats = list.filter((textoTitulo, indice) => list.indexOf(textoTitulo) !== indice);
             for (const raiz of [...new Set(repeats)]) {
                 ocorrencias.push(warn(messages.TailwindMensagens.repeatedClass(raiz), relPath, line));
             }
             if (uniqTokens.length > 1) {
-                // Mensagem: mostra a chave sem o prefixo de variantes para não poluir,
-                // mas mantém as classes originais nos exemplos.
                 const normalizedChave = key.includes('|') ? key.split('|').slice(1).join('|') : key;
                 ocorrencias.push(warn(messages.TailwindMensagens.conflictingClasses(normalizedChave, uniqTokens.slice(0, 4)), relPath, line));
-                // Detect variant conflicts for same property across multiple variants
                 const propSuffix = normalizedChave;
                 const variantsSet = new Set();
                 for (const chave of Object.keys(seen)) {
@@ -383,13 +399,12 @@ function collectTailwindIssues(src, relPath) {
                 }
             }
         }
-        // Detect variant conflicts across properties even when each variant has unique token
         const propVariants = {};
         for (const chave of Object.keys(seen)) {
             const parts = chave.split('|');
             const varPart = parts.length > 1 ? parts[0] : '';
             const propPart = parts.length > 1 ? parts.slice(1).join('|') : chave;
-            if (!propVariants[propPart]) {
+            if (!(propPart in propVariants)) {
                 propVariants[propPart] = new Set();
             }
             propVariants[propPart].add(varPart || 'base');
@@ -400,7 +415,6 @@ function collectTailwindIssues(src, relPath) {
             }
         }
     }
-    // Arbitrary values: sinalizar para revisão
     const safeArbitrary = /(var\()|(rgb\()|(hsl\()|(calc\()|url\(|linear-gradient|conic-gradient|radial-gradient|\d+(px|rem|em|%|vh|vw|ms|s|deg|fr)?\]|\d+\/\d+|\[--|^\d+\/\d+|\d+px|\d+rem|\d+em|\d+%|\d+deg|\d+fr/i;
     const allTokens = extractClasses(src);
     allTokens.filter(({ token }) => /\[.*\]/.test(token)).forEach(({ token, line }) => {
@@ -409,22 +423,32 @@ function collectTailwindIssues(src, relPath) {
             ocorrencias.push(warn(messages.TailwindMensagens.dangerousArbitraryValue(token), relPath, line));
             return;
         }
-        // Evita ruído: ignore vars, cores, gradientes, calc, unidades comuns, etc.
         if (safeArbitrary.test(token)) {
             return;
         }
         ocorrencias.push(warn(messages.TailwindMensagens.arbitraryValue(token), relPath, line));
     });
-    // Important usage detection (e.g., 'text-red-500!')
     allTokens.filter(({ token }) => /!$/.test(token) || /!\]/.test(token)).forEach(({ token, line }) => {
         ocorrencias.push(warn(messages.TailwindMensagens.importantUsage(token), relPath, line, messages.SeverityNiveis.suggestion));
     });
+    if (/@tailwind\s+(base|components|utilities)/.test(src)) {
+        ocorrencias.push(warn('Diretiva @tailwind detectada (v3) - use @import "tailwindcss" (v4)', relPath, 1, messages.SeverityNiveis.warning));
+    }
+    if (/@layer\s+utilities/.test(src)) {
+        ocorrencias.push(warn('@layer utilities detectado (v3) - use @utility (v4)', relPath, 1, messages.SeverityNiveis.suggestion));
+    }
+    if (/\btheme\(/.test(src)) {
+        ocorrencias.push(warn('Função theme() detectada (deprecated v3) - prefira CSS variables (var(--color-*))', relPath, 1, messages.SeverityNiveis.suggestion));
+    }
+    if (/\[--[^\]]+\]/.test(src)) {
+        ocorrencias.push(warn('Variável em colchetes (v3) - use parênteses (ex: bg-(--brand-color) ao invés de bg-[--brand-color])', relPath, undefined, messages.SeverityNiveis.suggestion));
+    }
     return ocorrencias;
 }
 export const analistaTailwind = criarAnalista({
     nome: 'analista-tailwind',
     categoria: 'estilo',
-    descricao: 'Heurísticas leves de Tailwind.',
+    descricao: 'Heurísticas de Tailwind CSS v4.',
     global: false,
     test: (relPath) => /\.(jsx|tsx|js|ts|html|astro)$/i.test(relPath),
     aplicar: (src, relPath) => {

package/dist/analysts/tailwind/corrections/correction-tailwind.js

@@ -1,15 +1,37 @@
 // SPDX-License-Identifier: MIT
-/**
- * [CHAVE-INGLESA] Correções automáticas para Tailwind CSS
- *
- * Fornece correções sugeridas para problemas comuns em Tailwind:
- * - Remover classes duplicadas
- * - Consolidar classes conflitantes
- * - Sugerir config para arbitrary values
- */
 import { messages } from '../../../core/messages/index.js';
 import { splitLines } from '../../../shared/helpers/index.js';
 import { criarOcorrencia } from '../../../types/index.js';
+const V3_TO_V4_CLASSES = {
+    'shadow-sm': 'shadow-xs',
+    'drop-shadow-sm': 'drop-shadow-xs',
+    'blur-sm': 'blur-xs',
+    'backdrop-blur-sm': 'backdrop-blur-xs',
+    'rounded-sm': 'rounded-xs',
+    'outline-none': 'outline-hidden',
+    'flex-shrink': 'shrink',
+    'flex-grow': 'grow',
+    'overflow-ellipsis': 'text-ellipsis',
+    'decoration-slice': 'box-decoration-slice',
+    'decoration-clone': 'box-decoration-clone',
+};
+const V3_TO_V4_SUFFIX_CLASSES = {
+    'shadow': 'shadow-sm',
+    'drop-shadow': 'drop-shadow-sm',
+    'blur': 'blur-sm',
+    'backdrop-blur': 'backdrop-blur-sm',
+    'rounded': 'rounded-sm',
+    'ring': 'ring-3',
+};
+function detectarClasseV3Deprecated(classe) {
+    return V3_TO_V4_CLASSES[classe] ?? null;
+}
+function detectarClasseSufixoV3(classe) {
+    const base = classe.split(':').pop() ?? classe;
+    const variante = classe.endsWith(base) ? '' : classe.slice(0, -base.length);
+    const sub = V3_TO_V4_SUFFIX_CLASSES[base];
+    return sub ? `${variante}${sub}` : null;
+}
 export function detectarCorrecoesTailwind(src, _relPath) {
     const correcoes = [];
     const linhas = splitLines(src);
@@ -28,6 +50,83 @@ export function detectarCorrecoesTailwind(src, _relPath) {
                     confianca: 95
                 });
             }
+            for (const cls of unique) {
+                const v4Class = detectarClasseV3Deprecated(cls);
+                if (v4Class) {
+                    correcoes.push({
+                        tipo: 'tailwind-v3-to-v4-rename',
+                        original: cls,
+                        sugerido: v4Class,
+                        linha: numeroLinha,
+                        confianca: 98
+                    });
+                }
+                const v4Suffix = detectarClasseSufixoV3(cls);
+                if (v4Suffix) {
+                    correcoes.push({
+                        tipo: 'tailwind-v3-to-v4-rename',
+                        original: cls,
+                        sugerido: v4Suffix,
+                        linha: numeroLinha,
+                        confianca: 95
+                    });
+                }
+                if (cls.startsWith('!')) {
+                    const cleanCls = cls.replace(/^!/, '');
+                    if (cleanCls) {
+                        correcoes.push({
+                            tipo: 'tailwind-important-prefix-to-suffix',
+                            original: cls,
+                            sugerido: `${cleanCls}!`,
+                            linha: numeroLinha,
+                            confianca: 97
+                        });
+                    }
+                }
+            }
+        }
+        const directClassMatch = linha.match(/\bclass(Name)?\s*=\s*\{/);
+        if (directClassMatch) {
+            const importantPrefixMatch = linha.match(/["'`]\s*!([\w-]+)/);
+            if (importantPrefixMatch) {
+                correcoes.push({
+                    tipo: 'tailwind-important-prefix-to-suffix',
+                    original: `"!${importantPrefixMatch[1]}"`,
+                    sugerido: `"${importantPrefixMatch[1]}!"`,
+                    linha: numeroLinha,
+                    confianca: 90
+                });
+            }
+        }
+        const v3VariableArbitrary = linha.match(/\[--([^\]]+)\]/);
+        if (v3VariableArbitrary) {
+            correcoes.push({
+                tipo: 'tailwind-arbitrary-var-syntax',
+                original: `[--${v3VariableArbitrary[1]}]`,
+                sugerido: `(--${v3VariableArbitrary[1]})`,
+                linha: numeroLinha,
+                confianca: 98
+            });
+        }
+        const tailwindDirective = linha.match(/@tailwind\s+(base|components|utilities)/);
+        if (tailwindDirective) {
+            correcoes.push({
+                tipo: 'tailwind-v3-to-v4-import',
+                original: linha.trim(),
+                sugerido: `@import "tailwindcss"`,
+                linha: numeroLinha,
+                confianca: 98
+            });
+        }
+        const layerUtilities = linha.match(/@layer\s+utilities\s*\{/);
+        if (layerUtilities) {
+            correcoes.push({
+                tipo: 'tailwind-layer-to-utility',
+                original: linha.trim(),
+                sugerido: `Use @utility nome-da-utilidade { ... } ao invés de @layer utilities`,
+                linha: numeroLinha,
+                confianca: 85
+            });
         }
     });
     return correcoes;
@@ -35,7 +134,7 @@ export function detectarCorrecoesTailwind(src, _relPath) {
 export const correctionTailwind = {
     nome: 'correction-tailwind',
     categoria: 'estilo',
-    descricao: 'Correções automáticas para problemas Tailwind',
+    descricao: 'Correções automáticas para Tailwind CSS v4',
     test: (relPath) => /\.(jsx|tsx|js|ts|html|astro)$/i.test(relPath),
     aplicar: (src, relPath) => {
         if (!src) {

package/dist/analysts/tailwind/detectors/detector-tailwind-best-practices.js

@@ -1,6 +1,27 @@
 // SPDX-License-Identifier: MIT
 import { splitLines } from '../../../shared/helpers/index.js';
 import { criarOcorrencia } from '../../../types/index.js';
+const V3_DEPRECATED_UTILITIES_MAP = {
+    'shadow-sm': 'shadow-xs',
+    'drop-shadow-sm': 'drop-shadow-xs',
+    'blur-sm': 'blur-xs',
+    'backdrop-blur-sm': 'backdrop-blur-xs',
+    'rounded-sm': 'rounded-xs',
+    'outline-none': 'outline-hidden',
+    'flex-shrink': 'shrink',
+    'flex-grow': 'grow',
+    'overflow-ellipsis': 'text-ellipsis',
+    'decoration-slice': 'box-decoration-slice',
+    'decoration-clone': 'box-decoration-clone',
+};
+const V3_SUFFIX_UTILITIES_MAP = {
+    'shadow': 'shadow-sm',
+    'drop-shadow': 'drop-shadow-sm',
+    'blur': 'blur-sm',
+    'backdrop-blur': 'backdrop-blur-sm',
+    'rounded': 'rounded-sm',
+    'ring': 'ring-3',
+};
 const TAILWIND_UTILITIES = new Set([
     'bg-', 'text-', 'm-', 'mt-', 'mr-', 'mb-', 'ml-', 'mx-', 'my-',
     'p-', 'pt-', 'pr-', 'pb-', 'pl-', 'px-', 'py-',
@@ -11,13 +32,16 @@ const TAILWIND_UTILITIES = new Set([
     'transition', 'duration-', 'ease-', 'animate-',
     'z-', 'overflow-', 'cursor-', 'select-', 'blur-',
     'top-', 'left-', 'right-', 'bottom-', 'inset-',
+    'field-sizing-', 'text-shadow-', 'inset-shadow-', 'zoom-', 'perspective-',
+    'outline-', 'drop-shadow-', 'backdrop-blur-',
 ]);
 const TAILWIND_COLORS = [
     'slate', 'gray', 'zinc', 'neutral', 'stone', 'red', 'orange', 'amber',
     'yellow', 'lime', 'green', 'emerald', 'teal', 'cyan', 'sky', 'blue',
     'indigo', 'violet', 'purple', 'fuchsia', 'pink', 'rose',
+    'mauve', 'olive', 'mist', 'taupe',
 ];
-function _isTailwindColor(value) {
+function isTailwindColor(value) {
     return TAILWIND_COLORS.some(c => value.includes(c));
 }
 function getPropertyKey(token) {
@@ -45,12 +69,27 @@ function getPropertyKey(token) {
     if (/^opacity/.test(token)) {
         return 'opacity';
     }
+    if (/^field-sizing/.test(token)) {
+        return 'field-sizing';
+    }
+    if (/^text-shadow/.test(token)) {
+        return 'text-shadow';
+    }
+    if (/^inset-shadow/.test(token)) {
+        return 'inset-shadow';
+    }
+    if (/^zoom/.test(token)) {
+        return 'zoom';
+    }
+    if (/^perspective/.test(token)) {
+        return 'perspective';
+    }
     return null;
 }
 export const detectorTailwindBestPractices = {
     nome: 'detector-tailwind-best-practices',
     categoria: 'estilo',
-    descricao: 'Detecta más práticas em Tailwind CSS',
+    descricao: 'Detecta más práticas em Tailwind CSS v4',
     test: (relPath) => /\.(jsx|tsx|js|ts|html|astro)$/i.test(relPath),
     aplicar: (src, relPath) => {
         if (!src) {
@@ -62,10 +101,86 @@ export const detectorTailwindBestPractices = {
         let inlineStyleCount = 0;
         linhas.forEach((linha, index) => {
             const numeroLinha = index + 1;
-            if (/\bclass(Name)?\s*=\s*["'][^"']*["']/.test(linha)) {
+            if (/@tailwind\s+(base|components|utilities)/.test(linha)) {
+                ocorrencias.push(criarOcorrencia({
+                    tipo: 'tailwind-v3-directive',
+                    nivel: 'aviso',
+                    mensagem: 'Diretiva @tailwind detectada (v3) - use @import "tailwindcss"',
+                    relPath,
+                    linha: numeroLinha,
+                    sugestao: 'Substitua @tailwind base/components/utilities por @import "tailwindcss"'
+                }));
+            }
+            if (/@layer\s+utilities\s*\{/.test(linha)) {
+                ocorrencias.push(criarOcorrencia({
+                    tipo: 'tailwind-v3-layer-utilities',
+                    nivel: 'info',
+                    mensagem: '@layer utilities detectado (v3) - use @utility (v4)',
+                    relPath,
+                    linha: numeroLinha,
+                    sugestao: 'Use @utility nome-da-utilidade { ... } ao invés de @layer utilities { ... }'
+                }));
+            }
+            if (/\btheme\(/.test(linha)) {
+                ocorrencias.push(criarOcorrencia({
+                    tipo: 'tailwind-theme-function',
+                    nivel: 'info',
+                    mensagem: 'theme() detectado (deprecated v3) - use CSS variables',
+                    relPath,
+                    linha: numeroLinha,
+                    sugestao: 'Substitua theme(colors.red.500) por var(--color-red-500)'
+                }));
+            }
+            if (/\bclass(Name)?\s*=\s*["'][^"']*![\w-]/.test(linha)) {
+                ocorrencias.push(criarOcorrencia({
+                    tipo: 'tailwind-important-prefix',
+                    nivel: 'info',
+                    mensagem: '!important como prefixo (v3) - mova ! para o final da classe',
+                    relPath,
+                    linha: numeroLinha,
+                    sugestao: 'Use "flex!" ao invés de "!flex"'
+                }));
+            }
+            if (/\bclass(Name)?\s*=\s*["'][^"']*\[--[^\]]+\]/.test(linha)) {
+                ocorrencias.push(criarOcorrencia({
+                    tipo: 'tailwind-arbitrary-var-syntax',
+                    nivel: 'info',
+                    mensagem: 'Variável em colchetes (v3) - use parênteses (v4)',
+                    relPath,
+                    linha: numeroLinha,
+                    sugestao: 'Use bg-(--brand-color) ao invés de bg-[--brand-color]'
+                }));
+            }
+            if (/\bclass(Name)?\s*=\s*["']([^"']*)["']/.test(linha)) {
                 const classMatch = linha.match(/\bclass(Name)?\s*=\s*["']([^"']*)["']/);
                 if (classMatch) {
                     const classes = classMatch[2].split(/\s+/).filter(Boolean);
+                    for (const cls of classes) {
+                        const v4Equivalent = V3_DEPRECATED_UTILITIES_MAP[cls];
+                        if (v4Equivalent) {
+                            ocorrencias.push(criarOcorrencia({
+                                tipo: 'tailwind-v3-deprecated-utility',
+                                nivel: 'aviso',
+                                mensagem: `Classe obsoleta do v3: "${cls}" → use "${v4Equivalent}"`,
+                                relPath,
+                                linha: numeroLinha,
+                                sugestao: `Substitua ${cls} por ${v4Equivalent}`
+                            }));
+                        }
+                        const baseClass = cls.split(':').pop() ?? cls;
+                        if (baseClass && V3_SUFFIX_UTILITIES_MAP[baseClass]) {
+                            const variante = cls.endsWith(baseClass) ? '' : cls.slice(0, -baseClass.length);
+                            const v4Suffix = V3_SUFFIX_UTILITIES_MAP[baseClass];
+                            ocorrencias.push(criarOcorrencia({
+                                tipo: 'tailwind-v3-deprecated-utility',
+                                nivel: 'aviso',
+                                mensagem: `Classe renomeada no v4: "${cls}" → use "${variante}${v4Suffix}"`,
+                                relPath,
+                                linha: numeroLinha,
+                                sugestao: `Substitua ${cls} por ${variante}${v4Suffix} (ex: shadow → shadow-sm)`
+                            }));
+                        }
+                    }
                     const seen = new Map();
                     classes.forEach(token => {
                         const base = token.split(':').pop() ?? token;
@@ -139,7 +254,7 @@ export const detectorTailwindBestPractices = {
                     }
                     const hardcodedValues = classes.filter(c => {
                         const val = c.split('-').pop() ?? '';
-                        return /^\d+$/.test(val) && !TAILWIND_COLORS.some(col => c.includes(col)) && val.length > 2;
+                        return /^\d+$/.test(val) && !isTailwindColor(c) && val.length > 2;
                     });
                     if (hardcodedValues.length > 0 && !hardcodedValues.some(v => /^[0-9]+\/[0-9]+$/.test(v))) {
                         ocorrencias.push(criarOcorrencia({
@@ -148,7 +263,7 @@ export const detectorTailwindBestPractices = {
                             mensagem: 'Valor hardcoded detectado - use tokens de design do Tailwind',
                             relPath,
                             linha: numeroLinha,
-                            sugestao: 'Extraia cores, espaçamentos e tamanhos para o tailwind.config.js'
+                            sugestao: 'Extraia cores, espaçamentos e tamanhos para @theme no CSS (v4)'
                         }));
                     }
                 }
@@ -166,7 +281,7 @@ export const detectorTailwindBestPractices = {
                                     mensagem: `Valor arbitrário detectado: ${val}`,
                                     relPath,
                                     linha: numeroLinha,
-                                    sugestao: 'Considere adicionar ao tailwind.config.js'
+                                    sugestao: 'Considere adicionar ao @theme no CSS (v4)'
                                 }));
                             }
                         }
@@ -204,7 +319,7 @@ export const detectorTailwindBestPractices = {
                 mensagem: 'Uso excessivo de valores arbitrários - pode indicar falta de tokens de design',
                 relPath,
                 linha: 1,
-                sugestao: 'Defina tokens personalizados em tailwind.config.js ao invés de valores arbitrários'
+                sugestao: 'Defina tokens personalizados via @theme no CSS ao invés de valores arbitrários'
             }));
         }
         return ocorrencias;