synthesisui 0.16.188 → 0.16.190

package/dist/anatomy-from-sketch.js

@@ -237,6 +237,33 @@ const MEMBER_FORM = {
  * already the recipe's `base`, and emitting it again would draw the component
  * inside a copy of itself.
  */
+/**
+ * COMO A PEÇA DA BIBLIOTECA FOI USADA, verbatim - e ela nunca atravessava.
+ *
+ * O sketch já lia `behaviourProps` no ponto de chamada (`open`, `onOpenChange`, `disabled`) e o
+ * contrato já tinha o campo; entre um e outro não havia ninguém carregando. Medido no repo do dono em
+ * 09/08: 15 nós carregavam as props na leitura e ZERO chegavam na receita.
+ *
+ * É a metade que decide se um agente consegue reproduzir o componente sem inventar: `Collapsible.Root`
+ * sozinho não diz se o disclosure é controlado; `Collapsible.Root` com `open` e `onOpenChange` diz.
+ *
+ * Teto de 12 props e 200 caracteres cada: isto viaja no censo e uma expressão de chamada pode ser uma
+ * linha inteira de código. O que passa disso é ruído no lugar onde a receita precisa ser lida.
+ */
+function behaviour(node) {
+    const raw = node.behaviourProps;
+    if (!raw || typeof raw !== "object")
+        return {};
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (Object.keys(out).length >= 12)
+            break;
+        if (typeof value !== "string" || !key)
+            continue;
+        out[key] = value.slice(0, 200);
+    }
+    return Object.keys(out).length > 0 ? { behaviourProps: out } : {};
+}
 export function anatomyFromSketch(sketch, defines, 
 /**
  * Their manifest: a package name → the range they pinned. This is what tells
@@ -335,6 +362,7 @@ versionOf) {
                     as: held.length > 0 ? "stack" : "text",
                     from: String(node.from ?? tag),
                     refName: tag,
+                    ...behaviour(node),
                     /** Its own index, so its guard and its props are still reachable - see `at`. */
                     at: index,
                     ...(held.length > 0 ? { children: held } : {}),
@@ -352,6 +380,8 @@ versionOf) {
                 {
                     as: "component",
                     ref: tag,
+                    /** Como ELE configurou o próprio componente é receita igual - ver `behaviour`. */
+                    ...behaviour(node),
                     /**
                      * THE INDEX IS THE NODE'S IDENTITY ON THE SKETCH, not a pointer to its classes.
                      *
@@ -380,6 +410,16 @@ versionOf) {
                 {
                     as: "external",
                     from: String(node.from ?? tag),
+                    /**
+                     * QUAL PEÇA, e não só de qual pacote - o ramo headless já dizia isto e o opaco não.
+                     *
+                     * `Collapsible.Root` e `Collapsible.Trigger` vêm do mesmo especificador e não são a mesma
+                     * coisa: quem gera código a partir da receita tem de saber qual das duas escrever. Medido
+                     * no repo do dono em 09/08: dos 119 nós de fronteira, 42 diziam a peça e 77 diziam apenas
+                     * o pacote - e os 77 eram exatamente este ramo.
+                     */
+                    refName: tag,
+                    ...behaviour(node),
                     at: index,
                     ...(children.length > 0 ? { children: descend() } : {}),
                 },
@@ -513,8 +553,14 @@ versionOf) {
          * props are copied into the snippet and can never fire, because the element unmounts
          * before anything animates. Headless-only dropped it (dono, 04/08).
          */
+        /**
+         * Uma primitiva headless DESENHADA continua sendo daquela biblioteca, e as props do ponto de
+         * chamada são o que dizem se ela é controlada. Medido em 09/08: `Collapsible.Root`,
+         * `Popover.Root`, `Switch.Root`, `BaseDialog.Root` e `Field.Root` chegavam aqui e perdiam
+         * `open`/`onOpenChange`/`checked` - 11 dos 15 nós que a leitura media.
+         */
         const fromLib = (kind === "headless" || kind === "motion") && node.from
-            ? { from: String(node.from), refName: tag }
+            ? { from: String(node.from), refName: tag, ...behaviour(node) }
             : {};
         const built = {
             as,

package/dist/commands/import.js

@@ -32,7 +32,7 @@ import { MUI_DEFAULT_SPACING, readStyledComponents, spacingOf, } from "../doctor
 import { buildTable } from "../doctor/tokens.js";
 import { definitionSpan, readInlineStyle, rootClasses, rootTag, transcribe, } from "../doctor/transcribe.js";
 import { transcribeVariants } from "../doctor/variant-read.js";
-import { frontierKind } from "../frontier-kind.js";
+import { frontierKind, packageRoot } from "../frontier-kind.js";
 import { withLibraryStructure } from "../library-structure.js";
 import { body, paint, section } from "../output.js";
 import { phase, startProgress } from "../progress.js";
@@ -2478,7 +2478,17 @@ export async function resolveReadParts(census, root) {
                 .filter((lib) => !resolved.external.some((e) => e.from === lib.from))
                 .map((lib) => ({
                 from: lib.from,
-                ...(pinned[lib.from] ? { version: pinned[lib.from] } : {}),
+                /**
+                 * PELA RAIZ DO PACOTE, e não pelo especificador inteiro.
+                 *
+                 * O `package.json` declara `@base-ui/react`; o código importa
+                 * `@base-ui/react/collapsible`. Consultar o manifesto com o segundo acerta só quando os
+                 * dois coincidem - medido no repo do dono em 09/08, 95 de 119 nós de fronteira chegavam
+                 * sem versão, e uma receita de biblioteca headless sem versão é um palpite datado.
+                 */
+                ...(pinned[packageRoot(lib.from)]
+                    ? { version: pinned[packageRoot(lib.from)] }
+                    : {}),
                 /**
                  * EVERY KIND, not the two the rule sentence happened to need.
                  *

package/dist/frontier-kind.js

@@ -118,7 +118,14 @@ export function frontierKind(pkg) {
     return "opaque";
 }
 /** `@scope/name/sub` → `@scope/name`; `name/sub` → `name`. */
-function packageRoot(pkg) {
+/**
+ * O NOME DO PACOTE, do especificador inteiro: `@base-ui/react/collapsible` -> `@base-ui/react`.
+ *
+ * Exportado em 09/08 porque o carimbo de VERSÃO consultava o manifesto com o especificador cru, e o
+ * `package.json` declara a raiz. Resultado medido no repo do dono: 95 de 119 nós de fronteira
+ * chegavam sem versão, e os 24 que chegavam eram justamente os que importam da raiz.
+ */
+export function packageRoot(pkg) {
     const parts = pkg.split("/");
     return pkg.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
 }

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
 import { absorb } from "./commands/absorb.js";
 import { add } from "./commands/add.js";
 import { adopt } from "./commands/adopt.js";
@@ -26,6 +27,7 @@ import { sync } from "./commands/sync.js";
 import { template } from "./commands/template.js";
 import { upgrade } from "./commands/upgrade.js";
 import { use } from "./commands/use.js";
+import { appendEvent } from "./doctor/ledger.js";
 import { RegistryError } from "./registry.js";
 /** Our own version, for pinning the hook and MCP commands we write into a
  *  project. Read from the package we are running out of, so a pinned command
@@ -602,7 +604,107 @@ async function main() {
             process.exitCode = 1;
     }
 }
-main().catch((err) => {
+/**
+ * TODA EXECUÇÃO DEIXA UMA LINHA - e ela é escrita AQUI, nunca dentro de um comando.
+ *
+ * Metade dos defeitos de 09/08 era comportamento da ferramenta: um `upgrade` que rematerializava sem
+ * medir, uma barra que entupia o clipboard, um aviso de versão invertido. Nenhum virava número em
+ * lugar nenhum, e os três foram achados pelo dono lendo a saída no terminal. A tela de causas era
+ * sólida sobre o que a gente PRODUZ e cega sobre o que a ferramenta FAZ.
+ *
+ * NO PONTO DE ENTRADA, por uma razão que já custou caro duas vezes hoje: um comando pode esquecer de
+ * se registrar, e um caminho novo dentro dele nasce esquecido. A porta não esquece.
+ *
+ * E NO `finally`, porque a execução que mais importa registrar é a que NÃO terminou. Uma queda que
+ * não deixa rastro é exatamente "perder uma entrada".
+ *
+ * O registro nunca derruba o comando nem muda o código de saída: ele é a nossa ferramenta de
+ * diagnóstico, e perder o trabalho de alguém para gravar uma linha dela seria a pior troca da esteira.
+ */
+/**
+ * A MENSAGEM SEM O DISCO DELE - o que este registro pode carregar, e o que ele nunca pode.
+ *
+ * O spec que executa o CLI pegou o vazamento na primeira rodada: a mensagem de erro trazia o
+ * argumento digitado, e mensagens de Node trazem caminho absoluto o tempo todo (`ENOENT: … open
+ * '/home/alguem/projeto/src/App.tsx'`). Um registro que carrega o caminho do projeto de alguém é um
+ * registro que ninguém deixa ligado - e aí a esteira perde o sinal inteiro, não só a linha.
+ *
+ * O que sobra é a FORMA do erro, que é o que dá para consertar a partir daqui. Caminho vira `<path>`;
+ * o resto passa.
+ */
+function scrub(message) {
+    return message
+        .replace(/[A-Za-z]:\\[^\s'"`)]+/g, "<path>")
+        .replace(/(?:\.{0,2}\/)[^\s'"`)]{2,}/g, "<path>")
+        .trim();
+}
+async function recordRun(command, started, ok, error, bytes) {
+    try {
+        const root = resolve(typeof parseFlags(process.argv.slice(2)).flags.dir === "string"
+            ? parseFlags(process.argv.slice(2)).flags.dir
+            : process.cwd());
+        const message = scrub(error instanceof Error ? error.message : error ? String(error) : "");
+        await appendEvent(root, {
+            kind: "run",
+            at: new Date().toISOString(),
+            command,
+            ok,
+            ms: Date.now() - started,
+            /** Só a primeira linha, cortada: uma stack carrega caminhos do projeto de alguém. */
+            ...(message ? { error: message.split("\n")[0].slice(0, 200) } : {}),
+            ...(typeof bytes === "number" && bytes > 0 ? { bytes } : {}),
+        });
+    }
+    catch {
+        /** Sem ledger, sem `_synthesisui`, disco cheio: nada disso é um comando que falhou. */
+    }
+}
+/**
+ * QUANTO O COMANDO ESCREVEU NA TELA - o segundo defeito de 09/08, e ele É medível.
+ *
+ * A barra de progresso se redesenha com `\r`: na tela é uma linha, no clipboard são todos os quadros.
+ * O dono tentou copiar a saída de um `sync` para mostrar um problema e levou junto 2 172 quadros -
+ * 195 879 bytes -, e o relatório que ele queria ficou enterrado. Aquilo foi achado por ele tentando
+ * copiar; não havia número em lugar nenhum.
+ *
+ * Contar bytes é a coisa mais simples que pega essa família inteira: uma saída de 200 KB não é uma
+ * saída, é um despejo, e a diferença entre 12 KB e 200 KB não depende de ninguém perceber.
+ *
+ * O contador NÃO altera a saída - ele soma e delega. Um wrapper que muda o que é impresso seria uma
+ * ferramenta mentindo sobre si mesma no exato lugar onde a gente foi conferir a verdade.
+ */
+function countingStdout() {
+    const original = process.stdout.write.bind(process.stdout);
+    let bytes = 0;
+    process.stdout.write = ((chunk, ...rest) => {
+        bytes +=
+            typeof chunk === "string"
+                ? Buffer.byteLength(chunk)
+                : Buffer.isBuffer(chunk)
+                    ? chunk.length
+                    : 0;
+        return original(chunk, ...rest);
+    });
+    return () => bytes;
+}
+async function guarded() {
+    const started = Date.now();
+    const command = parseFlags(process.argv.slice(2)).positionals[0] ?? "";
+    /** `help` e a invocação vazia não são trabalho sobre um projeto, e registrá-las seria só ruído. */
+    const worth = command && command !== "help";
+    const written = worth ? countingStdout() : () => 0;
+    try {
+        await main();
+        if (worth)
+            await recordRun(command, started, process.exitCode !== 1, undefined, written());
+    }
+    catch (err) {
+        if (worth)
+            await recordRun(command, started, false, err, written());
+        throw err;
+    }
+}
+guarded().catch((err) => {
     if (err instanceof RegistryError) {
         console.error(`error: ${err.message}`);
     }

package/dist/repo-state.js

@@ -39,7 +39,24 @@ export async function repoStateOf(projectRoot, slug, cli) {
      * própria aqui seria uma segunda implementação do formato do registro - e a primeira coisa que
      * ela faria é discordar da outra sobre o que é uma linha válida.
      */
-    const doctor = (await readEvents(projectRoot))
+    const events = await readEvents(projectRoot);
+    /**
+     * AS ÚLTIMAS 20, e a janela é deliberada: o que interessa é a sessão de agora, não o histórico.
+     * Uma pessoa que roda vinte comandos sem sincronizar está no meio de um problema, e é dessa vintena
+     * que sai a resposta.
+     */
+    const runs = events
+        .filter((e) => e.kind === "run" && e.command && e.at)
+        .slice(-20)
+        .map((e) => ({
+        command: String(e.command),
+        at: String(e.at),
+        ...(e.ok === false ? { ok: false } : {}),
+        ...(typeof e.ms === "number" ? { ms: Math.round(e.ms) } : {}),
+        ...(e.error ? { error: String(e.error).slice(0, 200) } : {}),
+        ...(typeof e.bytes === "number" ? { bytes: Math.round(e.bytes) } : {}),
+    }));
+    const doctor = events
         .filter((e) => e.kind === "doctor" && e.at)
         .sort((a, b) => String(b.at).localeCompare(String(a.at)))[0];
     const payload = {
@@ -56,6 +73,7 @@ export async function repoStateOf(projectRoot, slug, cli) {
         ...(doctor?.matched && doctor.matched.length > 0
             ? { matched: doctor.matched }
             : {}),
+        ...(runs.length > 0 ? { runs } : {}),
         ...(typeof lock?.fetchedAt === "string"
             ? { installedAt: lock.fetchedAt }
             : {}),

package/package.json

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