synthesisui 0.16.379 → 0.16.380

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/package.json

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