synthesisui 0.16.362 → 0.16.364

package/dist/commands/align.js

@@ -10,6 +10,7 @@ import { readRequests } from "../doctor/requests.js";
 import { declaredReference } from "../group-role.js";
 import { CHECKER_SINCE, installedBehind, MATERIALISER_SINCE, READER_SINCE, } from "../install-marks.js";
 import { fmt, say } from "../lang.js";
+import { mcpAwaitingApproval } from "../mcp-approval.js";
 import { measuredScope } from "../measured-scope.js";
 import { body, bodyWrapped, paint, section, snippet } from "../output.js";
 import { SKILLS } from "../skills.js";
@@ -96,6 +97,25 @@ export async function localMisalignments(root,
 opts = {}) {
     const { cli, home = homedir() } = opts;
     const out = [];
+    /**
+     * O PORTÃO QUE MATOU UM IMPORT INTEIRO, dito na sessão em que ele está fechado.
+     *
+     * Medido em 03/09: o agente mediu 262 arquivos, leu 78 componentes, descreveu a paleta dele - e
+     * parou, porque o playbook do import é servido pelo MCP e a aprovação estava pendente. Isto vem
+     * ANTES de qualquer outro desalinho porque é o único que impede a jornada principal de começar:
+     * um repo sem sistema não está desalinhado, e um repo cujas ferramentas ninguém aprovou não pode
+     * nem medir de volta.
+     *
+     * `/mcp` e não um comando de terminal: quem aprova é o agente, e um `npx` aqui mandaria a pessoa
+     * ao lugar errado. Ver `mcp-approval.ts` para de onde o estado é lido, e para o silêncio quando
+     * não há como saber.
+     */
+    if ((await mcpAwaitingApproval(root, home).catch(() => null)) === true)
+        out.push({
+            says: "The system's tools are declared here and still waiting for your approval - until you give it, I cannot reach the import playbook, only measure your files.",
+            run: "/mcp",
+            then: "then say: import my design system",
+        });
     const locks = (await locksIn(root)).filter((l) => l.slug && !l.adopted);
     /** Sem sistema instalado não há alinho a cobrar - não é desalinho, é um repo sem DS. */
     if (locks.length === 0)

package/dist/commands/gaps.js

@@ -15,12 +15,12 @@
 import { readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { describeTriage, triageLedger } from "../doctor/gap-triage.js";
-import { body, section } from "../output.js";
+import { body, bodyWrapped, paint, section } from "../output.js";
 export async function gaps(opts) {
     const root = opts.dir ?? process.cwd();
     const path = opts.census ?? join(root, "_synthesisui", "census.json");
     const raw = await readFile(path, "utf8").catch(() => null);
-    console.log(section("What this pipeline did not read"));
+    console.log(section(opts.brief ? "What we read" : "What this pipeline did not read"));
     if (!raw) {
         console.log(body(`No measurement at ${path}. Run \`synthesisui import --dry\` first - that is what measures your files, and it writes the result there.`));
         return;
@@ -46,6 +46,8 @@ export async function gaps(opts) {
         console.log(body(`This measurement was written by a tool version that did not count style fragments yet, so the numbers do not exist rather than being zero. Run \`synthesisui import --dry\` again with ${opts.cli} to measure.`));
         return;
     }
+    if (opts.brief)
+        return brief(ledger, values);
     for (const line of describeTriage(triageLedger(ledger, opts.cli), values))
         console.log(body(line));
     /**
@@ -91,6 +93,47 @@ export async function gaps(opts) {
  * vazia. Em qualquer um dos três não há nada a dizer, e uma frase que aparece sempre é uma frase que
  * ninguém lê.
  */
+/**
+ * O RESULTADO E UMA AÇÃO - o fechamento de um import.
+ *
+ * TRÊS DECISÕES DE DESENHO, e cada uma responde a algo que o dono viu na tela em 03/09:
+ *
+ *   O PERCENTUAL EM AZUL. `paint.blue` é a cor que este produto reserva para o que está VIVO - a
+ *   barra de cobertura, os comandos, os links. A cobertura é o número que resume a entrega, e num
+ *   bloco de prosa cinza ela desaparecia ("deixe com um tom de outra cor").
+ *
+ *   A LACUNA EM UMA LINHA, COM ENDEREÇO. Ela continua dita - quantos fragmentos, em quantos
+ *   lugares - e a LISTA mora no comando sem `--brief`. Uma lacuna sem número seria silêncio; uma
+ *   lista no momento da entrega é pedir desculpa quando era hora de mostrar o resultado.
+ *
+ *   UMA CTA, COM O QUE ELA GANHA. O v2 já existe como rascunho; o que faltava era dizer o que
+ *   aprová-lo FAZ - agrupar cores quase iguais, nomear valor que carrega peso e não tem nome,
+ *   resolver o valor que carrega dois nomes dele. Um link sem consequência dita é um link que
+ *   espera para sempre.
+ */
+async function brief(ledger, values) {
+    const places = ledger.unread.length;
+    if (!values)
+        return;
+    const decisions = values.seen - values.structure;
+    const closed = values.interpreted + values.answered;
+    const pct = decisions > 0 ? Math.round((closed / decisions) * 100) : 0;
+    console.log(bodyWrapped(`${paint.blue(paint.strong(`${pct}%`))} of your design decisions are in the system - ${closed} of ${decisions}.`).join("\n"));
+    /**
+     * O QUE FALTA, NA MESMA UNIDADE DA LINHA DE CIMA - e a primeira versão desta função errou
+     * exatamente nisso.
+     *
+     * Ela dizia "222 fragments are not", ao lado de "920 de 1008": quem lê subtrai 88 e vê 222. É o
+     * mesmo defeito de duas unidades vizinhas que este PR conserta duas linhas acima, e eu o
+     * reintroduzi na frase nova. O resto vai em PONTOS PERCENTUAIS, que é a unidade que a pessoa
+     * acabou de ler, e o número de LUGARES é endereço e não contagem concorrente.
+     *
+     * E cala em 100%: "the other 0%" é uma linha que faz o leitor procurar o que não existe.
+     */
+    if (pct >= 100 || places === 0)
+        return;
+    console.log(bodyWrapped(paint.dim(`The other ${100 - pct}% sits in ${places} ${places === 1 ? "place" : "places"} - \`synthesisui gaps\` lists each one with the file and the line.`)).join("\n"));
+}
 async function carriedByGlobals(root) {
     const dir = join(root, "_synthesisui", "ds");
     const slugs = await readdir(dir).catch(() => []);

package/dist/index.js

@@ -347,6 +347,8 @@ async function main() {
              */
             await gaps({
                 dir,
+                /** `--brief`: o fechamento de um import - o resultado e UMA ação. Ver `gaps.ts`. */
+                ...(boolFlag(flags, "brief") ? { brief: true } : {}),
                 census: typeof flags.census === "string" ? flags.census : undefined,
                 cli: CLI_VERSION,
             });

package/dist/mcp-approval.js

@@ -0,0 +1,79 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * AS FERRAMENTAS DECLARADAS E ESPERANDO APROVAÇÃO - o portão que matou um import inteiro.
+ *
+ * O QUE O CLIENTE GANHA: a sessão em que a aprovação está pendente é a sessão que lhe diz isso.
+ * Antes ele descobria no meio do import, quando o agente já tinha medido o repositório e não tinha
+ * como continuar.
+ *
+ * MEDIDO em 03/09, no segundo import real do dono. Ele rodou `import my design system`, o agente
+ * mediu 262 arquivos, leu 78 componentes, descreveu a paleta dele - e parou:
+ *
+ *     synthesisui: npx synthesisui@latest mcp - ⏸ Pending approval
+ *
+ * O playbook do import é SERVIDO pelo MCP, então sem aprovação não há import: só medição. E o
+ * `connect` avisa - em uma linha cinza, a terceira de um bloco secundário. Um portão que interrompe
+ * a jornada principal não pode ser anunciado como nota de pé de página.
+ *
+ * A ORIGEM DO DADO. O Claude Code guarda a decisão no `~/.claude.json`, por projeto:
+ *
+ *     enabledMcpjsonServers    aprovados
+ *     disabledMcpjsonServers   recusados
+ *
+ * Um servidor declarado no `.mcp.json` que não está em nenhuma das duas listas está PENDENTE - e é
+ * exatamente o estado dele. Medido: as duas listas vazias, para aquele projeto.
+ *
+ * SÓ LEITURA, NUNCA ESCRITA. Aquele arquivo é a configuração pessoal dele e vale para todos os
+ * projetos dele - a mesma fronteira do `.zshrc`, que este produto só atravessa perguntando.
+ * Escrever a aprovação por ele seria decidir em nome dele sobre um portão de segurança.
+ *
+ * E CALA QUANDO NÃO SABE. Arquivo ausente, JSON que não parseia, projeto sem entrada, formato
+ * diferente do que a gente conhece: em todos, resposta `null` e nenhuma linha na tela. Um aviso
+ * baseado num formato que mudou é pior que silêncio, porque manda a pessoa procurar um botão que
+ * talvez não exista mais.
+ */
+/** O nome do nosso servidor no `.mcp.json` - ver `wireMcpAt`. */
+const SERVER = "synthesisui";
+/**
+ * `true` quando o nosso servidor está declarado no repositório e a decisão dele ainda não foi
+ * tomada. `null` quando não há como saber - e aí quem chama não diz nada.
+ */
+export async function mcpAwaitingApproval(root, home) {
+    const declared = await readFile(join(root, ".mcp.json"), "utf8").then((raw) => {
+        try {
+            const j = JSON.parse(raw);
+            return Boolean(j.mcpServers && SERVER in j.mcpServers);
+        }
+        catch {
+            return null;
+        }
+    }, () => false);
+    /** Sem declaração não há aprovação pendente: o caso é OUTRO, e o `connect` já o cobre. */
+    if (declared !== true)
+        return declared === null ? null : false;
+    const raw = await readFile(join(home, ".claude.json"), "utf8").catch(() => null);
+    if (raw == null)
+        return null;
+    let conf;
+    try {
+        conf = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const entry = conf.projects?.[root];
+    /**
+     * SEM ENTRADA PARA ESTE PROJETO a pessoa provavelmente nunca abriu o agente aqui - e aí não há
+     * aprovação pendente, há uma sessão que ainda não aconteceu. Dizer "aprove" a quem não foi
+     * perguntado é inventar um estado.
+     */
+    if (!entry)
+        return null;
+    const enabled = entry.enabledMcpjsonServers;
+    const disabled = entry.disabledMcpjsonServers;
+    /** Formato diferente do que a gente conhece: silêncio, nunca um palpite. */
+    if (!Array.isArray(enabled) || !Array.isArray(disabled))
+        return null;
+    return !enabled.includes(SERVER) && !disabled.includes(SERVER);
+}

package/package.json

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