synthesisui 0.16.139 → 0.16.141

package/dist/anatomy-read.js

@@ -65,9 +65,24 @@ const FRONTIERS = new Set(["component", "external"]);
  * its own box, because its styles already sit on the component's base.
  */
 const STRUCTURAL = /^(root|wrapper|base|el|outer)$/i;
-/** A pathological transcription of somebody's DOM, bounded. Six levels reaches
- *  any real component; past that it is layout divs all the way down. */
-const MAX_DEPTH = 6;
+/**
+ * A transcrição patológica do DOM de alguém, com teto - e o teto foi medido errado.
+ *
+ * "Seis níveis alcançam qualquer componente real; além disso são divs de layout até o fim" foi
+ * calibrado numa biblioteca de 36 componentes. Um app de 275 desmente: a leitura do
+ * `apps/web-dashboard` tem 64 nós além do 6, e a distribuição mostra que a cauda é fina e é
+ * CONTEÚDO (05/08):
+ *
+ *     nível  0    1    2    3    4    5    6    7   8  9
+ *     nós  923  935  871  609  405  231  139   50  12  2
+ *
+ * O que estava acontecendo com esses 64: `walk` retornava ali, então tudo abaixo do sexto nível era
+ * descartado em silêncio - a estrutura que o cliente escreveu, perdida sem uma linha de aviso.
+ *
+ * 10 cobre a população inteira com folga e mantém o teto contra recursão patológica, que é a razão
+ * de ele existir. Um número medido em vez de estimado.
+ */
+const MAX_DEPTH = 10;
 /**
  * The same ceiling the sketch measured, for the same reason.
  *

package/dist/commands/import.js

@@ -2254,7 +2254,7 @@ function rootBehaviour(tag, sketch) {
         ? { rootProps: first.behaviourProps }
         : {};
 }
-async function resolveReadParts(census, root) {
+export async function resolveReadParts(census, root) {
     /**
      * A READING IS OPTIONAL HERE. THE SKETCH IS NOT.
      *

package/dist/commands/sync.js

@@ -3,8 +3,9 @@ import { join, resolve } from "node:path";
 import { readToken, resolveRegistry } from "../config.js";
 import { readEvents } from "../doctor/ledger.js";
 import { checkableName, closeRequest, readRequests, verifyAndCloseRequests, } from "../doctor/requests.js";
-import { body, section } from "../output.js";
+import { body, paint, section } from "../output.js";
 import { repoStateOf } from "../repo-state.js";
+import { resolveReadParts, takeCensus } from "./import.js";
 /**
  * What each decision means ON THIS MACHINE - the card decides, the sync
  * enacts. The web never touches the local file; this line is printed right
@@ -83,6 +84,19 @@ export async function sync(opts) {
         console.log(body("No installed system here, so there is nowhere to sync to."));
         return;
     }
+    /**
+     * A MEDIÇÃO NOVA, ANTES DO REGISTRO - e é isto que faz um conserto de leitura alcançar alguém.
+     *
+     * Um leitor novo do CLI precisa OLHAR o repo: o que a plataforma guarda é o censo, e o fonte fica
+     * aqui por decisão de privacidade. Essa passada é irredutível. O que era redutível é a cerimônia -
+     * até hoje "re-importar" significava a skill inteira, seis perguntas, e um agente reescrevendo 261
+     * anatomias que já estavam gravadas (dono, 05/08).
+     *
+     * Então: a plataforma devolve o que já foi decidido (o escopo e a leitura), o CLI mede com o leitor
+     * ATUAL, funde a leitura no censo fresco, AVISA o que seria reescrito, e envia. Sem entrevista.
+     */
+    if (!opts.recordOnly)
+        await remeasure({ root, base, token, slug, cli: opts.cli });
     // Verification first, so the snapshot never reports "open" about something
     // the installed css already delivers - a request closes because a machine
     // CHECKED, not because someone remembered to say so (dono, 29/07).
@@ -152,3 +166,133 @@ export async function sync(opts) {
     console.log(body(`The record lives on your system's overview:`));
     console.log(body(`    ${base}/dashboard/mine/${slug}`));
 }
+/**
+ * MEDE DE NOVO, AVISA, E ENVIA - o corpo do `sync` que faz um leitor novo chegar num sistema.
+ *
+ * A ordem é a lei aqui, e cada passo existe por um caso real:
+ *
+ *   1. a plataforma devolve o ESCOPO e a LEITURA já gravados. Sem isto, o `sync` teria que
+ *      perguntar de novo o que já foi decidido, e um agente reescreveria 261 anatomias.
+ *   2. mede com o leitor ATUAL - é o único passo que precisa estar nesta máquina, porque o fonte
+ *      dele não sai daqui.
+ *   3. funde a leitura gravada no censo fresco. A anatomia é do agente; a medição é nossa.
+ *   4. AVISA antes de enviar o que seria reescrito, e pergunta. Avisar depois de escrever não é
+ *      avisar.
+ *   5. envia para a rota que atualiza o RASCUNHO pelo slug - nada publicado se move.
+ */
+async function remeasure(args) {
+    const { root, base, token, slug } = args;
+    const head = await fetch(`${base}/api/registry/ds/${slug}/reading`, {
+        headers: { Authorization: `Bearer ${token}` },
+    }).catch(() => null);
+    if (!head?.ok) {
+        console.log(section("Sync"));
+        console.log(body(head
+            ? `The registry answered ${head.status} for this system's reading, so nothing was re-measured. The record below still travels.`
+            : "Could not reach the registry, so nothing was re-measured. The record below still travels."));
+        return;
+    }
+    const stored = (await head.json());
+    /**
+     * SEM CENSO GRAVADO NÃO HÁ O QUE REMEDIR CONTRA. Um sistema que nasceu da galeria não tem escopo
+     * nem leitura, e medir o repo dele produziria um censo de um projeto que ninguém mapeou para ele.
+     */
+    if (!stored.hasCensus) {
+        console.log(section("Sync"));
+        console.log(body(`"${slug}" did not come from an import, so there is no measurement to refresh. Import it first: npx synthesisui import`));
+        return;
+    }
+    console.log(section("Measuring your repository again"));
+    console.log(body(paint.faint(`${stored.scope ? `scope ${stored.scope}` : "the whole repo"} · the reading you already authored travels unchanged`)));
+    const census = await takeCensus(stored.scope ? join(root, stored.scope) : root, {
+        ...(stored.scope ? { scopeLabel: stored.scope } : {}),
+        ...(args.cli ? { cli: args.cli } : {}),
+        /** O `--usage` é EVIDÊNCIA e leva rótulo: sem ele o censo não sabe de que app o número veio. */
+        usage: (stored.usage ?? []).map((u) => ({
+            path: join(root, u),
+            label: u,
+        })),
+    }).catch(() => null);
+    if (!census) {
+        console.log(body("The measurement failed, so nothing was sent."));
+        return;
+    }
+    /** A LEITURA GRAVADA ENTRA NO CENSO FRESCO - ver a rota `reading`. */
+    if (stored.reading)
+        census.reading = stored.reading;
+    await resolveReadParts(census, root).catch(() => { });
+    /**
+     * O AVISO, ANTES DE ENVIAR. `edited` são as receitas que uma pessoa escreveu na tela; o cruzamento
+     * com o que acabou de ser medido é uma interseção de conjuntos, e é por isso que ele mora aqui em
+     * vez de virar um gêmeo da regra que vive na plataforma.
+     */
+    const slugOf = (name) => name
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
+    const arriving = new Set(Object.keys(census.looks ?? {}).map(slugOf));
+    /**
+     * SÓ O QUE ESTE ENVIO TOCA. Uma receita que a pessoa editou e que a medição não traz fica onde
+     * está, e listá-la seria assustar sem motivo - o erro mais fácil de cometer neste aviso.
+     */
+    const hit = (stored.draft?.edited ?? []).filter((e) => arriving.has(e.component));
+    if (hit.length > 0) {
+        console.log("");
+        console.log(section("You have an active draft"));
+        console.log(body(stored.draft?.warning ??
+            `${hit.length} of the ${stored.draft?.components ?? "?"} components in it were written on the screen, and this send would rewrite them.`));
+        console.log(body(paint.faint(hit
+            .slice(0, 6)
+            .map((e) => `${e.component}${e.at ? ` (${e.at.slice(0, 10)})` : ""}`)
+            .join(" · "))));
+        if (!(await askToOverwrite())) {
+            console.log(body("Nothing was sent. Your draft is untouched."));
+            return;
+        }
+    }
+    const res = await fetch(`${base}/api/registry/ds/${slug}/census`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({ census }),
+    }).catch(() => null);
+    if (!res?.ok) {
+        console.log(body(res
+            ? `The registry answered ${res.status}. Nothing was written.`
+            : "Could not reach the registry. Nothing was written."));
+        return;
+    }
+    const out = (await res.json());
+    console.log("");
+    console.log(section("Sent"));
+    console.log(body(`${out.written ?? 0} of ${out.total ?? 0} components written.`));
+    for (const note of out.notes ?? [])
+        console.log(body(paint.faint(note)));
+    if (out.url)
+        console.log(body(out.url));
+}
+/**
+ * Pergunta uma vez, e só num terminal de verdade.
+ *
+ * Sem TTY a resposta é NÃO: uma invocação por script que sobrescreve trabalho de alguém porque
+ * ninguém estava lá para dizer não é o pior default possível. `--yes` é o caminho explícito.
+ */
+async function askToOverwrite() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return false;
+    const { createInterface } = await import("node:readline/promises");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question("  send anyway? [y/N]: ");
+        return /^y(es)?$/i.test(answer.trim());
+    }
+    catch {
+        return false;
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/index.js

@@ -54,8 +54,10 @@ Usage - governance (deterministic, FREE):
                                            something no reader would change
   synthesisui request [component|token]    the queue of what your agent needed and the system
                                            refused to invent (--done <id> closes one)
-  synthesisui sync                         send the local record - checks, fixes, open requests -
-                                           to your system's dashboard (by hand, never automatic)
+  synthesisui sync                         re-measure this repo with the current reader and send it,
+                                           reusing the reading you already authored, plus the local
+                                           record - checks, fixes, open requests (--record-only skips
+                                           the measurement, --yes skips the overwrite question)
   synthesisui hook                         the check itself; installed by connect, run by your editor
   synthesisui mcp                          the system as tools; installed by connect, run by your agent
 
@@ -422,8 +424,21 @@ async function main() {
             await clean({ dir, force: flags.force === true });
             break;
         case "sync":
-            // A versão que reporta o estado do repo - ver `repoStateOf`.
-            await sync({ dir, registry, cli: CLI_VERSION });
+            /**
+             * A versão que reporta o estado do repo - ver `repoStateOf` - e que MEDE: desde 05/08 o `sync`
+             * remede o repo com o leitor atual e reenvia, reusando a leitura já gravada. É o único comando
+             * do lado do cliente para fazer um conserto de leitura chegar.
+             *
+             * `--record-only` manda só o registro, e `--yes` não pergunta antes de sobrescrever receita
+             * escrita na tela. O default é medir e perguntar.
+             */
+            await sync({
+                dir,
+                registry,
+                cli: CLI_VERSION,
+                recordOnly: args.includes("--record-only"),
+                yes: args.includes("--yes"),
+            });
             break;
         case "request": {
             // `synthesisui request` lists; `request component --name x --for "..."`

package/dist/skill-import.js

@@ -1189,6 +1189,21 @@ three biggest items so they know whether it is worth opening now.
 found in their code, a token that is not ramp-shaped, a name the document refused. Read them
 and pass on the ones that matter.
 
+**And the notes now judge YOUR reading, which nothing did before.** \`validate_recipes\` looks at
+the \`anatomy\` inside a recipe; the anatomy you author travels in \`reading.components[X].anatomy\`,
+and until 05/08 no one looked at it - so a note may name findings the batch validator never saw.
+Two kinds, and both are yours to act on:
+
+- **structure that does not survive the reader.** Nine of these landed on a real import, every one
+  the same shape: a \`button\` holding a \`stack\`. Only \`row\` and \`stack\` arrange, so the children are
+  hoisted out and become siblings - the nesting they wrote is gone. Fix it in the reading and send
+  again; the note tells you the component and the path.
+- **references pointing at components the system does not contain.** 215 of 660 on that same
+  import. This one is usually NOT a mistake of yours: their component composes something the gate
+  left out, or something outside the scope that was measured. Say the number to the person and name
+  the top few, because a specimen there draws the reference and nothing else - and if the missing
+  piece is central to their system, the answer is a wider \`--scope\`, not a rewritten reading.
+
 ### 6. Close the loop in their repo
 
 The system is only worth something once it governs the code it came from:

package/package.json

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