synthesisui 0.16.408 → 0.16.410

package/dist/commands/doctor.js

@@ -16,7 +16,11 @@ import { diagnose, nameToWrite, scanSource, siblingTokens, } from "../doctor/sca
 import { findSelfConflicts, forbiddenProps, isReset, propMatchesLabel, } from "../doctor/self-conflict.js";
 import { withTheirNames } from "../doctor/their-names.js";
 import { buildTable, EMPTY_TABLE, nearestToken, } from "../doctor/tokens.js";
-import { detectAppDirs, globalSheetOf, prefixFrom } from "../global-sheet.js";
+/**
+ * `detectAppDirs` SAIU DESTE IMPORT em 09/09: quem pergunta "quais pastas são app?" agora é
+ * `readWiringPerApp`, que responde a fiação de cada uma. O comando não escolhe mais um app.
+ */
+import { globalSheetOf, prefixFrom } from "../global-sheet.js";
 import { groupRole } from "../group-role.js";
 import { actingSlug, describeScope, measuredScope, scopePaths, } from "../measured-scope.js";
 import { body, paint, section, snippet } from "../output.js";
@@ -25,7 +29,7 @@ import { installedThemeCss, whatOnlyTheSheetResolves, } from "../sheet-needed.js
 import { resolveDeps } from "../stack.js";
 import { projectTongue } from "../their-tongue.js";
 import { danglingTheirVars } from "../their-vars.js";
-import { readWiring } from "../wiring-read.js";
+import { readWiring, readWiringPerApp } from "../wiring-read.js";
 /**
  * `synthesisui doctor` - the check nobody else ships.
  *
@@ -1068,28 +1072,109 @@ export async function doctor(opts) {
          * inventado.
          */
         if (table.slug) {
-            const appDirs = await detectAppDirs(root, config.pagesDir);
-            const sheet = appDirs[0]
-                ? await globalSheetOf(root, `${appDirs[0]}/globals.css`)
-                : null;
-            console.log("");
-            console.log(body("Paste this into your agent - it does the setup for you:"));
-            console.log("");
-            console.log(snippet(setupPrompt(table.slug, {
-                tokens: !wiring.imported,
-                scope: !wiring.scoped,
-                /** Só é passo quando o projeto TEM o arquivo de fontes - ver `readWiring`. */
-                type: wiring.fontsWritten && !wiring.fontsMapped,
-                ...(sheet
-                    ? { sheet: { path: sheet, prefix: prefixFrom(sheet) } }
-                    : {}),
+            /**
+             * A INSTRUÇÃO É POR APP, e não do primeiro deles.
+             *
+             * O DEFEITO: esta linha era `appDirs[0]` - num monorepo com três apps servidos, dois recebiam
+             * a instrução do PRIMEIRO, com a folha e o prefixo relativo de outro app. É o mesmo defeito
+             * que `INV-VOLTA-12` fechou uma vez ("ele seguiu a instrução no arquivo CERTO e recebeu de nós
+             * o prefixo do arquivo errado"), voltando pela porta do plural: a invariante fala de "os apps
+             * dele", e o comando respondia por um.
+             *
+             * E A FIAÇÃO TAMBÉM É POR APP (`readWiringPerApp`): `readWiring` varre a raiz e responde
+             * "existe em algum lugar daqui", então o app fiado respondia pelo que não estava - e a pessoa
+             * abria o app sem nada e o comando dizia que estava tudo certo.
+             *
+             * COM UM APP, o texto não muda em byte nenhum - é a maioria dos projetos, e um cabeçalho
+             * por app ali seria cerimônia sobre uma lista de um.
+             */
+            const perApp = await readWiringPerApp(root, table.slug, config.pagesDir);
+            const targets = perApp.length > 0 ? perApp : [{ app: null, wiring }];
+            /**
+             * OS APPS QUE PEDEM A MESMA COISA VIRAM UM BLOCO SÓ, nomeando os dois.
+             *
+             * O DEFEITO, e ele é meu, do PR de algumas horas atrás: no `codelevel-monorepo` os DOIS apps
+             * resolvem para a MESMA folha (`packages/ui/src/styles/globals.css`, o pacote compartilhado),
+             * então o comando imprimiu a mesma instrução de 40 linhas DUAS VEZES, com o mesmo caminho e o
+             * mesmo prefixo. O dono leu a parede duas vezes (medido no repositório dele, 09/09).
+             *
+             * Eu tinha escrito o aviso no comentário abaixo - *"num monorepo ele apareceria em escala:
+             * dois blocos idênticos"* - sobre o caso do app JÁ FIADO, e entreguei a duplicata no caso do
+             * que ainda falta. Nomear cada app foi o conserto certo; repetir a instrução não.
+             *
+             * A CHAVE É A INSTRUÇÃO, não o app: dois apps com a mesma folha, o mesmo prefixo e os mesmos
+             * passos pendentes recebem uma instrução só. Um monorepo onde cada app tem folha própria volta
+             * a receber uma por app, porque ali as instruções DIFEREM - é a resposta derivada, e não uma
+             * regra sobre quantos apps existem.
+             */
+            const blocks = new Map();
+            for (const { app, wiring: w } of targets) {
+                const sheet = app
+                    ? await globalSheetOf(root, `${app}/globals.css`)
+                    : null;
+                /**
+                 * O APP QUE JÁ ESTÁ FIADO SAI DA LISTA, nomeado. Repetir o setup para quem já o fez é o
+                 * defeito de 08/09 outra vez.
+                 */
+                const pending = !w.imported || !w.scoped || (w.fontsWritten && !w.fontsMapped);
+                const text = pending
+                    ? setupPrompt(table.slug, {
+                        tokens: !w.imported,
+                        scope: !w.scoped,
+                        /** Só é passo quando o projeto TEM o arquivo de fontes - ver `readWiring`. */
+                        type: w.fontsWritten && !w.fontsMapped,
+                        ...(sheet
+                            ? { sheet: { path: sheet, prefix: prefixFrom(sheet) } }
+                            : {}),
+                        /**
+                         * DUAS LINHAS COM TAILWIND, UMA SEM - a mesma decisão que o `add` já toma pelo
+                         * projeto. Dizer "as duas linhas" a um projeto que precisa de uma manda o agente
+                         * procurar o que não existe.
+                         */
+                        imports: config.styles === "css" ? 1 : 2,
+                    }).split("\n")
+                    : [];
+                const key = `${pending ? "p" : "ok"}|${text.join("\n")}`;
+                const found = blocks.get(key);
+                if (found)
+                    found.apps.push(app ?? "");
+                else
+                    blocks.set(key, { apps: [app ?? ""], text, pending });
+            }
+            const anyPending = [...blocks.values()].some((b) => b.pending);
+            if (anyPending) {
+                console.log("");
+                console.log(body("Paste this into your agent - it does the setup for you:"));
+            }
+            for (const { apps, text, pending } of blocks.values()) {
+                const named = apps.filter(Boolean);
                 /**
-                 * DUAS LINHAS COM TAILWIND, UMA SEM - a mesma decisão que o `add` já toma pelo projeto.
-                 * Dizer "as duas linhas" a um projeto que precisa de uma manda o agente procurar o que
-                 * não existe.
+                 * O CABEÇALHO SÓ APARECE QUANDO HÁ MAIS DE UM APP no projeto - com um só ele seria cerimônia
+                 * sobre uma lista de um, e a maioria dos projetos é assim. Com vários, ele diz de QUEM é a
+                 * instrução, e o plural sai naturalmente: "apps/landing/app and apps/web/app".
                  */
-                imports: config.styles === "css" ? 1 : 2,
-            }).split("\n")));
+                if (targets.length > 1 && named.length > 0) {
+                    /**
+                     * A LISTA SE LÊ EM VOZ ALTA, e o número dela não é fixo: "A and B" com dois,
+                     * "A, B and C" com três. `join(" and ")` daria "A and B and C", e `"both"` mentiria
+                     * no dia em que o monorepo tiver três apps na mesma folha - o mesmo erro de
+                     * dimensionar pela amostra, na escala de uma palavra.
+                     */
+                    const lista = named.length > 1
+                        ? `${named.slice(0, -1).join(", ")} and ${named[named.length - 1]}`
+                        : named[0];
+                    console.log("");
+                    console.log(body(`  ${lista} - ${pending
+                        ? named.length > 1
+                            ? "need it, and the steps are the same"
+                            : "still needs it"
+                        : "already wired, nothing to paste"}`));
+                }
+                if (!pending)
+                    continue;
+                console.log("");
+                console.log(snippet(text));
+            }
         }
     }
     /**

package/dist/global-sheet.js

@@ -65,13 +65,39 @@ async function fromWorkspace(root, spec) {
 }
 /**
  * A folha onde os tokens dele devem entrar, relativa à raiz - `appSheet` quando nada a re-exporta.
+ *
+ * DELEGA, e não caminha: quem caminha é `sheetChainOf`. Dois caminhadores sobre a mesma cadeia é
+ * como um deles para de seguir um salto que o outro segue, e ninguém descobre até um cliente
+ * receber a instrução apontando para a folha errada - que é exatamente o defeito que
+ * `INV-VOLTA-12` fechou.
  */
 export async function globalSheetOf(root, appSheet) {
+    const chain = await sheetChainOf(root, appSheet);
+    return chain[chain.length - 1] ?? appSheet;
+}
+/**
+ * A CADEIA INTEIRA, da folha do app até a última que ninguém re-exporta - e por que ela é pública.
+ *
+ * O QUE O CLIENTE GANHA: a resposta "este app carrega o meu design system?" medida no app DELE, e
+ * não no projeto. `readWiring` varria a raiz e devolvia "existe em algum lugar daqui": num monorepo
+ * com dois apps servidos, um fiado e outro não, o fiado respondia pelo outro - e a pessoa recebia
+ * "está tudo certo" sobre o app que não carrega nada.
+ *
+ * A pergunta dos IMPORTS não se responde varrendo pasta: ela se responde seguindo a cadeia de
+ * `@import` a partir da folha daquele app, porque a folha que carrega os tokens quase nunca é a do
+ * app - num monorepo é a do pacote compartilhado, e os dois apps chegam nela.
+ *
+ * A ordem é do app para fora, e o teto de saltos é o mesmo: um ciclo de imports não pode travar um
+ * comando.
+ */
+export async function sheetChainOf(root, appSheet) {
+    const chain = [];
     let current = appSheet;
     for (let hop = 0; hop < MAX_HOPS; hop += 1) {
+        chain.push(current);
         const raw = await readFile(join(root, current), "utf8").catch(() => null);
         if (!raw)
-            return current;
+            return chain;
         let next = null;
         for (const m of raw.matchAll(IMPORT)) {
             const spec = m[1];
@@ -91,11 +117,12 @@ export async function globalSheetOf(root, appSheet) {
             next = candidate;
             break;
         }
-        if (!next || next === current)
-            return current;
+        /** Uma folha que aponta para si mesma encerra a cadeia em vez de gastar o teto de saltos. */
+        if (!next || next === current || chain.includes(next))
+            return chain;
         current = next;
     }
-    return current;
+    return chain;
 }
 /** O `../` que leva daquela folha até a raiz do repositório - o prefixo do `@import`. */
 export function prefixFrom(sheet) {

package/dist/wiring-read.js

@@ -2,6 +2,7 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { walk } from "./commands/doctor.js";
 import { FAMILY_SEAM_PREFIX } from "./fonts.js";
+import { detectAppDirs, sheetChainOf } from "./global-sheet.js";
 /**
  * A FIAÇÃO DESTE PROJETO, MEDIDA - e a mesma medição para todos os comandos que a citam.
  *
@@ -111,3 +112,79 @@ export async function readWiring(root, slug) {
     }
     return w;
 }
+/**
+ * A FIAÇÃO DE CADA APP, e num monorepo é ela que decide - `readWiring` acima não decide.
+ *
+ * O QUE O CLIENTE VIA: `readWiring` varre da RAIZ e responde "existe, em algum lugar daqui". Num
+ * monorepo com dois apps servidos, um fiado e outro não, o fiado respondia pelo outro: a pessoa
+ * abria o app que não carrega nada e o comando dizia que estava tudo certo. O contrato já declarava
+ * isso como lacuna (`INV-VOLTA-12`, "a resposta é do PROJETO, e num monorepo ela não decide") e o
+ * comando dizia o que mediu em vez de afirmar - honesto, e ainda a resposta errada.
+ *
+ * COMO A RESPOSTA CERTA É ENCONTRADA, e cada metade vem de onde ela mora:
+ *
+ *     os `@import`   seguindo a CADEIA de folhas a partir da folha daquele app (`sheetChainOf`).
+ *                    A folha que carrega os tokens quase nunca é a do app: num monorepo é a do
+ *                    pacote compartilhado, e os dois apps chegam nela - então varrer pasta daria
+ *                    "não" para os dois, e varrer a raiz dá "sim" para todos
+ *     o `data-ds`    na árvore DAQUELE app, porque o escopo mora no layout dele
+ *     as fontes      idem - `init` escreve o arquivo de fonte por app
+ *
+ * O QUE ESTA FUNÇÃO NÃO GENERALIZA, declarado com o N de hoje (medido em 09/09):
+ *
+ *     `detectAppDirs` só procura em `apps/` e `packages/`   cobre 4 de 4 monorepos medidos;
+ *                                                           `pnpm-workspace.yaml` aparece em 0 de 10
+ *     e só reconhece app pelo `layout` do App Router        cobre 7 de 7 raízes de app medidas;
+ *                                                           `vite` aparece só em PACOTE de
+ *                                                           biblioteca, corretamente ignorado
+ *
+ * As duas são estreitezas REAIS e as duas têm N=0 de evidência contrária hoje. Generalizá-las sem
+ * uma população que as exija seria dimensionar pela imaginação - o erro que `INV-GERAL-07` nomeia
+ * pelo avesso. Quando aparecer um repositório que caia fora, o número dele é que abre a frente.
+ */
+export async function readWiringPerApp(root, slug, pagesDir) {
+    if (!slug)
+        return [];
+    const apps = await detectAppDirs(root, pagesDir);
+    const out = [];
+    const hasShadcn = await readFile(join(root, "components.json"), "utf8").then(() => true, () => false);
+    for (const app of apps) {
+        const w = {
+            imported: false,
+            themed: false,
+            scoped: false,
+            fontsWritten: false,
+            fontsMapped: false,
+            hasShadcn,
+            bridged: false,
+        };
+        /** Os imports: a cadeia daquele app, e não a pasta dele. */
+        for (const sheet of await sheetChainOf(root, `${app}/globals.css`)) {
+            const css = await readFile(join(root, sheet), "utf8").catch(() => "");
+            if (!css)
+                continue;
+            if (css.includes(`_synthesisui/ds/${slug}/tokens.css`))
+                w.imported = true;
+            if (css.includes(`_synthesisui/ds/${slug}/theme.css`))
+                w.themed = true;
+            if (css.includes(`_synthesisui/ds/${slug}/shadcn.css`))
+                w.bridged = true;
+        }
+        /** O escopo e as fontes: a árvore DAQUELE app - é onde o layout dele mora. */
+        for await (const file of walk(join(root, app))) {
+            const src = await readFile(file, "utf8").catch(() => "");
+            if (!src)
+                continue;
+            if (src.includes(`data-ds="${slug}"`))
+                w.scoped = true;
+            if (src.includes("--font-ds-") && /next\/font/.test(src))
+                w.fontsWritten = true;
+            if (new RegExp(`${FAMILY_SEAM_PREFIX}\\w+\\s*:\\s*var\\(\\s*--font-ds-`).test(src))
+                w.fontsMapped = true;
+            if (w.scoped && w.fontsMapped)
+                break;
+        }
+        out.push({ app, wiring: w });
+    }
+    return out;
+}

package/package.json

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