synthesisui 0.16.189 → 0.16.191

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,135 @@ 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());
+        /**
+         * ONDE, DENTRO DO NOSSO CÓDIGO, e é o que separa uma queda consertável de uma inútil.
+         *
+         * `Cannot read properties of undefined` sem lugar nenhum não se conserta daqui - a única saída
+         * seria pedir para a pessoa reproduzir, que é exatamente o que não pode acontecer (dono, 09/08:
+         * *"não quero pedir para o usuário rodar alguma coisa porque a gente não pegou"*).
+         *
+         * O primeiro quadro da pilha que aponta para o NOSSO pacote resolve isso, e ele não é dado dele:
+         * `index.js:1234` é o nosso bundle. O diretório - que é o cache de npx na máquina dele - fica de
+         * fora, e um quadro que não seja nosso é descartado em vez de viajar.
+         */
+        const frame = (() => {
+            const stack = error instanceof Error ? (error.stack ?? "") : "";
+            for (const line of stack.split("\n").slice(1)) {
+                const at = /\(?([^()\s]+\.js):(\d+):(\d+)\)?\s*$/.exec(line.trim());
+                if (!at)
+                    continue;
+                const file = at[1].split("/").pop() ?? "";
+                /** Só o nosso bundle e os nossos módulos: um quadro do Node ou de outro pacote não é nosso. */
+                if (!file || /node:/.test(at[1]))
+                    continue;
+                if (!at[1].includes("synthesisui") && !at[1].endsWith("/dist/index.js"))
+                    continue;
+                return `${file}:${at[2]}`;
+            }
+            return "";
+        })();
+        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 } : {}),
+            ...(frame ? { where: frame } : {}),
+        });
+    }
+    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,25 @@ 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) } : {}),
+        ...(e.where ? { where: String(e.where).slice(0, 60) } : {}),
+    }));
+    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 +74,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.189",
+  "version": "0.16.191",
   "description": "Bring SynthesisUI design systems into any project - tokens, typed components, whole pages and an agent-ready CLAUDE.md manifest.",
   "type": "module",
   "bin": {