synthesisui 0.16.379 → 0.16.381

package/dist/commands/doctor.js

@@ -621,7 +621,10 @@ async function runFix(root, d, writing) {
         await appendEvent(root, {
             kind: "fix",
             at: new Date().toISOString(),
-            named: result.applied.length,
+            /** ESCRITAS, e não achados - ver `Applied.occurrences`: um achado de folha minificada vale
+             *  por sete trocas, e o ledger que contasse achados registraria um ato menor do que o que
+             *  aconteceu no repositório dele. */
+            named: result.applied.reduce((n, a) => n + a.occurrences, 0),
         });
         console.log("");
         console.log(body(paint.dim("Read the diff before committing - it is your code, and this replaced literals with the tokens your own system declares.")));

package/dist/doctor/apply-fix.js

@@ -18,8 +18,10 @@
  * confiança:
  *
  *   1. tocar uma linha que mudou desde a medição - se o texto não bate, pula e conta
- *   2. trocar mais de uma ocorrência por achado - dois `#fff` na mesma linha são dois achados,
- *      e cada um tem a sua própria linha no relatório
+ *   2. sair da linha que o achado nomeia - a troca acontece naquela linha e em nenhuma outra.
+ *      DENTRO dela, todas as ocorrências daquele valor são trocadas, e o recibo conta ESCRITAS,
+ *      não achados: o scan emite um achado por (arquivo, linha, valor), e numa folha minificada
+ *      esse um vale por sete
  *   3. escrever em arquivo que o scanner marcou como fora (gerado, vendored) - esses nunca
  *      chegam aqui, porque o walk já os pula
  */
@@ -27,17 +29,117 @@ import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { nameToWrite } from "./scan.js";
 /**
- * A substituição numa linha só, e ela é deliberadamente burra.
+ * ONDE O VALOR DE UMA DECLARAÇÃO DESTE MESMO TOKEN COMEÇA E TERMINA, nesta linha.
  *
- * `indexOf` do literal exato, primeira ocorrência, nada mais. Um literal de cor ou de comprimento não
- * tem sintaxe ambígua o suficiente para justificar um parser aqui, e um parser que erra num arquivo de
- * outra pessoa custa mais que os achados que ele conserta.
+ * Só os intervalos do token que a troca ESCREVERIA: é dentro deles, e só ali, que trocar produz
+ * `--x: var(--x)`. Todo o resto da linha - inclusive a declaração de OUTRO token dele - é uso
+ * legítimo, e continua trocável.
  */
-function swap(line, literal, token) {
-    const at = line.indexOf(literal);
-    if (at === -1)
-        return null;
-    return `${line.slice(0, at)}var(${token})${line.slice(at + literal.length)}`;
+function selfRanges(line, name) {
+    const out = [];
+    for (const m of line.matchAll(/(--[a-z0-9-]+)\s*:\s*([^;}]*)/gi)) {
+        if (m[1] !== name)
+            continue;
+        const at = (m.index ?? 0) + m[0].length - m[2].length;
+        out.push([at, at + m[2].length]);
+    }
+    return out;
+}
+/**
+ * A TROCA NA LINHA, EM TODAS AS VEZES QUE O VALOR APARECE NELA - e era aqui que o número mentia.
+ *
+ * O QUE ACONTECIA: o scan emite UM achado por (arquivo, linha, valor), e esta função trocava a
+ * PRIMEIRA ocorrência. Numa folha minificada a linha inteira é o arquivo: em
+ * `apps/landing/app/styles/pulse.css` a linha 7 escreve `#6b6b78` sete vezes, o comando trocava uma,
+ * contava uma, e deixava seis - sem dizer. A medição seguinte reencontrava o mesmo achado, e o número
+ * que o comando prometeu passava a não bater com o número que a próxima leitura mostra.
+ *
+ * MEDIDO EM DUAS POPULAÇÕES (05/09, pelo caminho real do `doctor --fix --write`, antes e depois):
+ *
+ *   codelevel      114 achados aplicados · escrevia 114 · agora escreve **126** · discrepância 5 -> 0
+ *   frontend-hub  1010 achados aplicados · escrevia 1010 · agora escreve **1012** · já era 0
+ *
+ * E A DIFERENÇA QUE ISTO FECHA: no codelevel o comando anunciava 114 trocas e a medição seguinte
+ * mostrava só 109 achados a menos - **5 sem explicação**, que são estes: cinco linhas onde o valor
+ * aparecia mais de uma vez, o achado continuava lá depois do conserto, e o cliente que rodasse os
+ * dois comandos em sequência via os dois números. Agora a queda é 114 de 114.
+ *
+ * O TETO É MAIOR QUE O EFEITO DE HOJE, e vale dizer: no codelevel, 39 dos 208 achados NOMEADOS
+ * escondem 235 ocorrências, 234 delas num único arquivo minificado - a maior parte em achados que o
+ * `--fix` ainda não aplica porque apontam para tokens nossos, que só resolvem depois da fiação. No
+ * dia em que ele fizer a fiação, são essas que passam a ser escritas.
+ *
+ * Não é forma de um repositório: é toda folha que alguém minifica, e todo arquivo que escreve o mesmo
+ * valor duas vezes na mesma linha.
+ *
+ * O GUARD DA AUTO-REFERÊNCIA PASSA A VALER POR OCORRÊNCIA, e não pela linha inteira. Numa linha que
+ * DECLARA o token e também o USA, recusar as duas coisas deixava o uso sem conserto por causa da
+ * vizinha; agora a declaração fica intacta e o uso é trocado. Quando toda ocorrência da linha é a
+ * própria declaração, o resultado é o de sempre: nada trocado, e o motivo dito.
+ *
+ * E O VALOR TEM QUE TERMINAR ONDE ELE TERMINA - ver `wholeValue`.
+ */
+/**
+ * A OCORRÊNCIA É O VALOR INTEIRO, E NÃO O COMEÇO DE OUTRO - e sem isto a troca escreve cor inválida.
+ *
+ * `#4f46e5` é um prefixo de `#4f46e50b`, que é a MESMA cor com alpha. Trocando pelo prefixo, a linha
+ * fica `var(--color-brand-blue)0b`: o navegador descarta a declaração inteira e o elemento perde a
+ * cor - o mesmo estrago do ciclo, por outro caminho. Vale igual para comprimento: `1rem` é prefixo de
+ * `1remx` e sufixo de `11rem`.
+ *
+ * NÃO É HIPÓTESE: `apps/landing/app/styles/pulse.css` escreve 8 valores em `#rrggbbaa`, e o
+ * `--fix` só não os atingia porque trocava a PRIMEIRA ocorrência da linha e ela calhava de ser um hex
+ * puro. Sorte da população, não proteção - e trocando todas, a sorte acaba.
+ */
+function wholeValue(line, at, literal) {
+    const before = at > 0 ? line[at - 1] : "";
+    const after = line[at + literal.length] ?? "";
+    return !/[0-9a-z#]/i.test(before) && !/[0-9a-z]/i.test(after);
+}
+/** Onde este valor está escrito INTEIRO nesta linha - a mesma pergunta que a troca faz. */
+function wholeValuesIn(line, literal) {
+    const out = [];
+    for (let at = line.indexOf(literal); at !== -1;) {
+        if (wholeValue(line, at, literal))
+            out.push(at);
+        at = line.indexOf(literal, at + literal.length);
+    }
+    return out;
+}
+function swapAll(line, literal, name) {
+    const guarded = selfRanges(line, name);
+    let out = "";
+    let from = 0;
+    let count = 0;
+    let blocked = 0;
+    for (;;) {
+        const at = line.indexOf(literal, from);
+        if (at === -1)
+            break;
+        const declares = guarded.some(([start, end]) => at >= start && at + literal.length <= end);
+        /**
+         * A BORDA NÃO CONTA COMO AUTO-REFERÊNCIA - senão o relatório dá o motivo de outro caso.
+         *
+         * `blocked` é só a declaração do próprio token, porque é ele que decide a frase impressa quando
+         * nada foi trocado. Um prefixo de valor maior não é uma recusa: é um valor que não está escrito
+         * naquela linha, e cai no motivo que já existe para isso.
+         */
+        if (!wholeValue(line, at, literal)) {
+            out += line.slice(from, at + literal.length);
+            from = at + literal.length;
+            continue;
+        }
+        if (declares) {
+            blocked++;
+            out += line.slice(from, at + literal.length);
+        }
+        else {
+            count++;
+            out += `${line.slice(from, at)}var(${name})`;
+        }
+        from = at + literal.length;
+    }
+    return { line: out + line.slice(from), count, blocked };
 }
 /**
  * Aplica o que tem token, em memória, e devolve o conteúdo novo por arquivo.
@@ -53,6 +155,15 @@ export function planFix(d, read) {
     const lines = new Map();
     /** A mesma chave, congelada antes da primeira troca - ver o skip de `not-written`. */
     const originals = new Map();
+    /**
+     * O MESMO VALOR, NA MESMA LINHA, APONTADO DUAS VEZES É UM CONSERTO SÓ - e não uma linha que mudou.
+     *
+     * A troca cobre TODAS as ocorrências daquela linha de uma vez, então um segundo achado idêntico não
+     * encontra mais o literal e cairia no skip de `moved`, que imprime *"linhas mudaram desde o scan -
+     * rode de novo"* num repositório onde ninguém mexeu em nada. Nada é perdido de vista: as duas
+     * escritas já estão contadas no `occurrences` do primeiro.
+     */
+    const done = new Set();
     /**
      * DE BAIXO PARA CIMA no arquivo não é necessário - a troca não muda a contagem de linhas - mas a
      * ORDEM por arquivo é, para dois achados na mesma linha não se atropelarem: o segundo procura o seu
@@ -172,10 +283,15 @@ export function planFix(d, read) {
          * seguem trocáveis: numa linha minificada, um `background:#fbfaf6` ao lado de um `--violet:...`
          * continua sendo um uso legítimo.
          */
-        const declaring = [
-            ...(current ?? "").matchAll(/(--[a-z0-9-]+)\s*:\s*([^;}]*)/gi),
-        ].find(([, , value]) => value?.includes(f.literal));
-        if (declaring && declaring[1] === name) {
+        const already = `${f.file}:${f.line}:${f.literal}`;
+        if (done.has(already))
+            continue;
+        const swapped = current === undefined ? null : swapAll(current, f.literal, name);
+        /**
+         * TODA OCORRÊNCIA DA LINHA ERA A PRÓPRIA DECLARAÇÃO - o caso que o guard sempre recusou, dito
+         * com a mesma frase de antes. O que mudou é que uma linha que declara E usa deixou de cair aqui.
+         */
+        if (swapped !== null && swapped.count === 0 && swapped.blocked > 0) {
             skipped.push({
                 file: f.file,
                 line: f.line,
@@ -184,8 +300,7 @@ export function planFix(d, read) {
             });
             continue;
         }
-        const swapped = current === undefined ? null : swap(current, f.literal, name);
-        if (swapped === null) {
+        if (swapped === null || swapped.count === 0) {
             /**
              * DOIS MOTIVOS DIFERENTES, E A TELA DIZIA UM SÓ - e o que ela dizia era falso quase sempre.
              *
@@ -215,19 +330,21 @@ export function planFix(d, read) {
                 file: f.file,
                 line: f.line,
                 literal: f.literal,
-                because: before === undefined || before.includes(f.literal)
+                because: before === undefined || wholeValuesIn(before, f.literal).length > 0
                     ? "moved"
                     : "not-written",
             });
             continue;
         }
-        body[idx] = swapped;
+        body[idx] = swapped.line;
         applied.push({
             file: f.file,
             line: f.line,
             literal: f.literal,
             token: name,
+            occurrences: swapped.count,
         });
+        done.add(already);
     }
     for (const [file, body] of lines) {
         const touched = applied.some((a) => a.file === file);
@@ -292,10 +409,17 @@ export function describeFix(result, dry) {
                                 : "Nothing to apply.");
         return lines;
     }
-    lines.push(`${dry ? "Would replace" : "Replaced"} ${applied.length} hand-written value${applied.length === 1 ? "" : "s"} with the token your system already has, across ${result.files} file${result.files === 1 ? "" : "s"}.`);
+    /**
+     * O NÚMERO É O DE ESCRITAS, e não o de achados - ver `Applied.occurrences`.
+     *
+     * Um achado numa linha minificada vale por sete trocas. Contando achados, o recibo dizia 114 onde o
+     * comando escreveu 349, e a medição seguinte não batia com nenhum dos dois números.
+     */
+    const uses = applied.reduce((n, a) => n + a.occurrences, 0);
+    lines.push(`${dry ? "Would replace" : "Replaced"} ${uses} hand-written value${uses === 1 ? "" : "s"} with the token your system already has, across ${result.files} file${result.files === 1 ? "" : "s"}.`);
     const byToken = new Map();
     for (const a of applied)
-        byToken.set(a.token, (byToken.get(a.token) ?? 0) + 1);
+        byToken.set(a.token, (byToken.get(a.token) ?? 0) + a.occurrences);
     const ranked = [...byToken.entries()].sort((a, b) => b[1] - a[1]);
     const SHOWN = 6;
     for (const [token, n] of ranked.slice(0, SHOWN))

package/dist/doctor/fragments.js

@@ -22,8 +22,28 @@ const CLASS_LITERAL = /className=(?:"([^"]{0,400})"|\{\s*"([^"]{0,400})"\s*\})/g
 const CLASS_TEMPLATE = /className=\{\s*`([^`]{0,400})`\s*\}/g;
 /** `className={algo}` sem literal nenhum: não existe na fonte. */
 const CLASS_RUNTIME = /className=\{\s*([A-Za-z_$][\w$.[\]]{0,60})\s*\}/g;
-/** Um literal dentro de `cn("…", …)` e amigos. */
-const CALL_LITERAL = /\b(?:cn|clsx|classNames|cx|twMerge|twJoin|classcat)\(([^)]{0,600})\)/g;
+/**
+ * A ABERTURA de `cn("…", …)` e amigos - o FIM sai por parêntese balanceado, e não por regex.
+ *
+ * O QUE ACONTECIA: o corpo era `([^)]{0,600})`, que para no PRIMEIRO `)`. Basta uma chamada aninhada
+ * - `cn("flex", buttonVariants({ size }), "p-4")` - para tudo o que vem depois dela desaparecer da
+ * conta. Não é o teto de 600: é o parêntese.
+ *
+ * MEDIDO EM TRÊS POPULAÇÕES (05/09, classes que o coletor não via por causa do corte):
+ *
+ *     codelevel/packages/ui             21   de 33 chamadas truncadas de 83
+ *     frontend-hub/packages/ui          41   de 17 chamadas truncadas de 78
+ *     frontend-hub/apps/web-dashboard    1   de  1 chamada  truncada  de 47
+ *
+ * E o que sumia não era resto: `shadow-[0_10px_30px_-10px_rgba(…)]`, `data-[starting-style]:…`,
+ * `bg-[var(--color-lightgray-300)]` - as classes mais ricas do repositório, que são exatamente as
+ * que o cliente quer ver contadas. Num ledger cuja promessa é que nada é descartado em silêncio,
+ * elas não eram lidas E não eram "não lidas": não existiam.
+ *
+ * É O MESMO PRECEDENTE do `sx` e do `styled` três blocos abaixo, e pela mesma razão: um regex com
+ * teto escolhe a formatação do arquivo de outra pessoa.
+ */
+const CALL_OPEN = /\b(?:cn|clsx|classNames|cx|twMerge|twJoin|classcat)\(/g;
 const STRING_IN_CALL = /"([^"]{0,300})"|'([^']{0,300})'/g;
 /** `style={{ … }}`. */
 const INLINE = /style=\{\{([^}]{0,400})\}\}/g;
@@ -72,6 +92,7 @@ const MODULE_REF = /\$\{\s*[A-Za-z_$][\w$]*\.[A-Za-z_$][\w$]*\s*\}/g;
  *
  *     status === "success" ? "bg-success-500" : ...     "success" é OPERANDO da comparação
  *     // ... to prevent the "short width" issue        "short width" está num COMENTÁRIO
+ *     cn(iconVariants({ animation: … : "none" }), …)   "none" é ARGUMENTO de outra chamada
  *
  * MEDIDO EM 11/08 no repo real, sobre as 26 declarações que o censo listava como `value-not-read`:
  *
@@ -93,6 +114,38 @@ function blankComments(body) {
 function isComparedTo(body, index) {
     return /(?:===|!==|==|!=)\s*$/.test(body.slice(0, index));
 }
+/** Um utilitário de classe abrindo parêntese, para saber QUEM abriu a chamada mais interna. */
+const OPENS_A_CLASS_CALL = /\b(?:cn|clsx|classNames|cx|twMerge|twJoin|classcat)\($/;
+/**
+ * O LITERAL É ARGUMENTO DE OUTRA CHAMADA, e argumento de outra chamada não é classe.
+ *
+ * `cn(iconVariants({ animation: shouldAnimate ? animation : "none" }), className)` põe `"none"`
+ * dentro do `cn`, mas ele não veste nada: é o valor que a função de variantes recebe para escolher a
+ * classe. A esteira listava `none` como uma classe que não conseguiu ler, e o cliente ia procurar no
+ * código dele um estilo que ele nunca escreveu - o mesmo custo do operando de `===` logo acima.
+ *
+ * MEDIDO EM TRÊS POPULAÇÕES (05/09, sobre os literais que já passam pelos dois guards anteriores):
+ *
+ *     codelevel/packages/ui             3 de  83   `"none"` em Card, Icon, Typography
+ *     frontend-hub/packages/ui          0 de 123
+ *     frontend-hub/apps/web-dashboard   0 de  68
+ *
+ * QUEM ABRIU A CHAMADA DECIDE, e não o simples fato de haver uma. Um utilitário de classe aninhado
+ * (`cn(clsx("flex"))`) continua vestindo, e o que está dentro dele É classe - sem esta metade, o
+ * conserto de um falso positivo criaria um falso negativo. Nas três populações essa forma dá N=0
+ * hoje; ela está aqui porque aninhar utilitário é forma de qualquer projeto, e o `CALL_LITERAL` só
+ * casa a chamada de fora.
+ */
+function isArgumentOfAnotherCall(body, index) {
+    const open = [];
+    for (let i = 0; i < index; i++) {
+        if (body[i] === "(")
+            open.push(!OPENS_A_CLASS_CALL.test(body.slice(0, i + 1)));
+        else if (body[i] === ")")
+            open.pop();
+    }
+    return open[open.length - 1] === true;
+}
 export function fragmentsOfSource(file, source) {
     const out = [];
     const at = (index) => source.slice(0, index).split("\n").length;
@@ -127,15 +180,28 @@ export function fragmentsOfSource(file, source) {
      * OS LITERAIS DENTRO DE UMA CHAMADA. `cn("flex p-4", cond && "gap-2")` tem dois, e os dois são
      * classe escrita à mão - a forma mais comum do repo dele (113 arquivos).
      */
-    for (const call of source.matchAll(CALL_LITERAL)) {
-        const body = blankComments(call[1] ?? "");
-        const base = (call.index ?? 0) + (call[0].length - body.length - 1);
+    /**
+     * SÓ A CHAMADA MAIS EXTERNA - senão um utilitário aninhado conta os literais dele duas vezes.
+     *
+     * Enquanto o corpo parava no primeiro `)`, um `clsx(` dentro de um `cn(` era uma segunda match e
+     * ninguém percebia. Com o corpo inteiro, o de fora já cobre o de dentro.
+     */
+    let until = 0;
+    for (const call of source.matchAll(CALL_OPEN)) {
+        const from = (call.index ?? 0) + call[0].length;
+        if (from < until)
+            continue;
+        until = closingParen(source, from);
+        const body = blankComments(source.slice(from, until));
+        const base = from;
         for (const s of body.matchAll(STRING_IN_CALL)) {
             const text = s[1] ?? s[2] ?? "";
             if (!LOOKS_LIKE_CLASS.test(text))
                 continue;
             if (isComparedTo(body, s.index ?? 0))
                 continue;
+            if (isArgumentOfAnotherCall(body, s.index ?? 0))
+                continue;
             push("class", base + (s.index ?? 0), text);
         }
     }
@@ -151,6 +217,19 @@ export function fragmentsOfSource(file, source) {
     }
     return out;
 }
+/** O fim da chamada aberta em `from`, contando parênteses. Sem fechamento, o fim do arquivo. */
+function closingParen(source, from) {
+    let depth = 1;
+    let i = from;
+    while (i < source.length && depth > 0) {
+        if (source[i] === "(")
+            depth += 1;
+        else if (source[i] === ")")
+            depth -= 1;
+        i += 1;
+    }
+    return depth === 0 ? i - 1 : source.length;
+}
 /** O fim de um objeto aberto com duas chaves - `sx={{ … }}` fecha em duas. */
 function balanced(source, from, close) {
     let depth = 2;

package/dist/install-marks.js

@@ -680,7 +680,7 @@ export const CHECKER_SINCE = "0.16.378";
  * posição de conteúdo. Um censo medido antes desta versão conta como deriva o que a folha do app
  * nem alcança - e o número do cliente é a promessa.
  */
-export const READER_SINCE = "0.16.378";
+export const READER_SINCE = "0.16.381";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synthesisui",
-  "version": "0.16.379",
+  "version": "0.16.381",
   "description": "Bring SynthesisUI design systems into any project - tokens, typed components, whole pages and an agent-ready CLAUDE.md manifest.",
   "type": "module",
   "bin": {