synthesisui 0.16.449 → 0.16.451

package/dist/commands/hook.js

@@ -1,10 +1,11 @@
 import { readFile, stat, writeFile } from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
 import { changedSince } from "../changed-files.js";
-import { emptyTally, internalSpecifiers, scanComponentsInto, tallyToInventory, } from "../doctor/components-scan.js";
+import { emptyTally, exportedNames, internalSpecifiers, scanComponentsInto, tallyToInventory, } from "../doctor/components-scan.js";
 import { checkContracts } from "../doctor/contract-check.js";
 import { appendEvent, ledgerPath } from "../doctor/ledger.js";
 import { diagnose, nameToWrite, scanSource } from "../doctor/scan.js";
+import { declarados, falaDaPrateleira, naPrateleira } from "../doctor/shelf.js";
 import { governs, ungovernedIn } from "../governed.js";
 import { readMode } from "../mode.js";
 import { namesRemoved, previousText, rulesTouchedBy, } from "../rule-touched.js";
@@ -361,7 +362,14 @@ async function report(root, filePath, mode) {
      * parte do relatório que RECUSA, e uma recusa escondida embaixo de uma lista de valores é uma
      * recusa que ninguém lê.
      */
+    /**
+     * A PRATELEIRA VEM ANTES DOS VALORES, e a ordem é o ponto: trocar um hex por
+     * um token num componente que não precisava existir é polir o que devia ser
+     * apagado. Se a peça já está no sistema, essa é a primeira coisa a saber.
+     */
+    const prateleira = falaDaPrateleira(rel, naPrateleira(exportedNames(src), declarados(documents)), table.name ?? table.slug ?? "this system");
     const lines = [
+        ...(prateleira.length > 0 ? [...prateleira, ""] : []),
         ...(composed.length > 0 ? [...composed, ""] : []),
         ...(broke.length > 0 ? [...broke, ""] : []),
         `${rel} - checked against ${table.name ?? table.slug}.`,

package/dist/commands/import.js

@@ -2417,7 +2417,23 @@ export async function takeCensus(root, opts) {
      * e e' exatamente o caso que fazia o `canvas` ser escolhido por casamento de palavra.
      * Ver `root-ground.ts` para a medicao do `codelevel` que motivou isto.
      */
-    const rootGround = rootGroundOf(globalSheets.map((g) => ({ file: g.file, css: g.body })));
+    const rootGround = rootGroundOf(
+    /**
+     * SÓ AS FOLHAS DENTRO DO ESCOPO - corrigido em 21/09, na primeira corrida real.
+     *
+     * A versao de estreia leu TODAS as folhas colhidas e o `codelevel` respondeu com
+     * `_local/bkp/scrollytelling/styles.css`: um backup morto, fora do escopo declarado
+     * (`packages/ui`), que declara `html, body { background: var(--bg) }` com tokens que
+     * o projeto de hoje nao tem. A regra certa estava tres arquivos ao lado e perdeu para
+     * a ordem da varredura.
+     *
+     * `g.outside` ja existia e ja era contado logo acima, em `deForaDoEscopo` - eu e que
+     * nao o usei. Um chao lido de codigo morto e pior que nenhum: ele tem a confianca de
+     * uma medicao e a procedencia de um arquivo que ninguem executa.
+     */
+    globalSheets
+        .filter((g) => !g.outside)
+        .map((g) => ({ file: g.file, css: g.body })));
     const declaredSchemes = {
         base: Object.fromEntries(schemes.base),
         light: Object.fromEntries(schemes.light),

package/dist/doctor/components-scan.js

@@ -274,6 +274,40 @@ function importedNames(source, internal = []) {
  */
 const BOUND = /(?:const|let|var|function|class)\s+([A-Z][A-Za-z0-9_]*)|[{,]\s*\w+\s*:\s*([A-Z][A-Za-z0-9_]*)\s*(?:=[^,}]*)?\s*[,}]/g;
 const EXPORTED_NAME = /export\s+(?:default\s+)?(?:async\s+)?(?:function|class|const|let|var)\s+([A-Z][A-Za-z0-9_]*)|export\s+default\s+([A-Z][A-Za-z0-9_]*)|export\s*\{([^}]*)\}/g;
+/**
+ * OS COMPONENTES QUE ESTE ARQUIVO EXPORTA - a metade que faltava para o hook
+ * enxergar a PRATELEIRA, e não só os valores.
+ *
+ * O hook já dizia "este valor tem nome no sistema". Ele nunca dizia "esta PEÇA
+ * tem recipe no sistema", e o agente do CodeLevel mediu o efeito disso em
+ * 22/09: escreveu cinco componentes do zero num dia, com pelo menos quatro
+ * deles já existindo no índice - *"a ferramenta estava ligada o dia inteiro e
+ * eu não fiz uma pergunta a ela"*.
+ *
+ * Reusa a mesma regex de `localOnlyNames`, que é quem já sabe ler as quatro
+ * formas de exportar. Duas leituras do mesmo formato discordariam um dia.
+ */
+export function exportedNames(source) {
+    const nomes = new Set();
+    EXPORTED_NAME.lastIndex = 0;
+    for (const m of source.matchAll(EXPORTED_NAME)) {
+        if (m[1])
+            nomes.add(m[1]);
+        if (m[2])
+            nomes.add(m[2]);
+        if (m[3]) {
+            for (const cru of m[3].split(",")) {
+                const nome = cru
+                    .trim()
+                    .split(/\s+as\s+/)[0]
+                    ?.trim();
+                if (nome && /^[A-Z]/.test(nome))
+                    nomes.add(nome);
+            }
+        }
+    }
+    return nomes;
+}
 export function localOnlyNames(source) {
     const exported = new Set();
     EXPORTED_NAME.lastIndex = 0;

package/dist/doctor/shelf.js

@@ -0,0 +1,91 @@
+/**
+ * A PRATELEIRA - "esta peça já existe no sistema", dito sem ninguém perguntar.
+ *
+ * O PROBLEMA, medido em 22/09 no CodeLevel. O agente escreveu cinco componentes
+ * do zero num dia; pelo menos quatro já existiam no índice do sistema. Ele
+ * mesmo contou o porquê: *"o AGENTS.md manda consultar o índice antes de
+ * escrever UI (...) não consultei uma única vez. Também não chamei nenhuma das
+ * ferramentas dele"*. E fechou: *"a ferramenta estava ligada o dia inteiro e eu
+ * não fiz uma pergunta a ela"*.
+ *
+ * As duas metades do produto têm caminhos diferentes, e é isso que explica o
+ * resultado: a GUARDA roda no hook, sem pedir licença, e funcionou 209 de 209.
+ * A BIBLIOTECA é MCP - `list_components`, `describe_component` -, e MCP é PULL:
+ * só acontece se o agente resolver perguntar. Ele não resolveu nenhuma vez.
+ *
+ * Isto põe a biblioteca no caminho de push.
+ *
+ * ─────────────────────────────────────────────────────────────────────────
+ * A DISCIPLINA, e ela é a parte importante deste arquivo.
+ *
+ * Casar NOME é a família de defeito que este repositório já pagou caro: nome
+ * vencendo a leitura foi o erro do importador. Então aqui:
+ *
+ *   IGUALDADE EXATA, depois de normalizar. Nada de substring, prefixo,
+ *   distância de edição ou plural. `Card` casa com `card`; `CardHeader` não
+ *   casa com `card`, e é melhor perder o aviso do que dar um errado.
+ *
+ *   É PERGUNTA, NUNCA VEREDITO. O texto não diz "você errou": diz que os dois
+ *   nomes coincidem e pergunta se são a mesma coisa.
+ *
+ *   A CHECAGEM DECLARA A PRÓPRIA FRAQUEZA na saída. Quem lê é um agente, e um
+ *   agente que recebe "isto já existe" como fato vai apagar trabalho certo.
+ */
+/** `StatCard` → `stat-card`; `DSCard` → `ds-card`. */
+export function normalizar(nome) {
+    return nome
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
+        .toLowerCase();
+}
+/** Os componentes que o sistema declara, de um documento de design system. */
+export function declarados(documents) {
+    const nomes = new Set();
+    for (const doc of documents) {
+        const comps = doc?.components;
+        if (comps)
+            for (const k of Object.keys(comps))
+                nomes.add(normalizar(k));
+        const blocos = doc?.blocks;
+        if (blocos)
+            for (const k of Object.keys(blocos))
+                nomes.add(normalizar(k));
+    }
+    return nomes;
+}
+/**
+ * O que este arquivo define E o sistema já declara. Vazio é a resposta normal.
+ *
+ * `ds-` some do nome declarado antes de comparar: o sistema guarda `card` e a
+ * classe emitida é `ds-card`, e um repositório que chama a peça dele de `DsCard`
+ * está falando do mesmo componente.
+ */
+export function naPrateleira(exportados, sistema) {
+    const achados = [];
+    for (const nome of exportados) {
+        const n = normalizar(nome);
+        const semPrefixo = n.startsWith("ds-") ? n.slice(3) : n;
+        if (sistema.has(n))
+            achados.push({ escrito: nome, declarado: n });
+        else if (sistema.has(semPrefixo))
+            achados.push({ escrito: nome, declarado: semPrefixo });
+    }
+    return achados;
+}
+/** O texto que o agente lê. Pergunta, com a fraqueza declarada. */
+export function falaDaPrateleira(rel, achados, sistema) {
+    if (achados.length === 0)
+        return [];
+    return [
+        `${rel} - ${sistema} already declares ${achados.length === 1 ? "a component" : "components"} with ${achados.length === 1 ? "this name" : "these names"}:`,
+        ...achados.map((a) => `  you wrote ${a.escrito}  ·  the system has ${a.declarado}`),
+        "",
+        "If they are the same thing, materialize the system's instead of keeping yours - it arrives already wearing the tokens, and it stays in step when the system changes.",
+        /**
+         * A FRAQUEZA VAI JUNTO. Esta checagem compara NOME, e nome colide: um
+         * `Card` de dashboard e um `card` de baralho são palavras iguais e coisas
+         * diferentes. Sem esta linha, um agente obediente apaga trabalho certo.
+         */
+        "This check compares NAMES only, and names collide. If yours is a different thing, keep it and say so in your summary.",
+    ];
+}

package/package.json

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