synthesisui 0.16.190 → 0.16.192

package/dist/index.js

@@ -643,6 +643,33 @@ async function recordRun(command, started, ok, error, bytes) {
         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",
@@ -653,6 +680,7 @@ async function recordRun(command, started, ok, error, bytes) {
             /** 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 {

package/dist/progress.js

@@ -12,6 +12,9 @@
  * skill runs the CLI with no TTY and pipes the output, so it gets a plain milestone
  * line every so often. Neither has to know about the other, and the non-TTY path never
  * writes a carriage return into a transcript.
+ *
+ * E OS DOIS ESCREVEM EM `stderr`, porque progresso não é resultado: quem redireciona a saída fica com
+ * o relatório limpo, e quem está na tela continua vendo tudo.
  */
 const BAR_WIDTH = 24;
 /**
@@ -22,11 +25,11 @@ const BAR_WIDTH = 24;
  * 08/08 o dono tentou copiar a saída de um `sync` e levou junto 2 172 quadros - um por arquivo de
  * evidência -, o que enterrou o relatório que ele queria mostrar (dono, 08/08).
  *
- * 80ms é o teto do que um olho aproveita: acima de ~12 quadros por segundo a animação já lê como
- * contínua, e o resto é trabalho que só o clipboard vê. No caso dele isso troca 2 172 quadros por
- * algumas dezenas, sem tirar um único frame que alguém fosse perceber.
+ * 250ms, e o número subiu de 80ms em 09/08 por uma razão de LEITURA e não só de clipboard: a linha
+ * mostra o arquivo sendo lido, e a 12 quadros por segundo o nome vira borrão. A quatro por segundo dá
+ * para de fato ler o que está passando - fica melhor na tela E três vezes menor no texto colado.
  */
-const MIN_FRAME_MS = 80;
+const MIN_FRAME_MS = 250;
 /** Every this-many items, the non-TTY path prints one line. Enough to see movement in
  *  a piped log without turning it into the log. */
 const MILESTONE_EVERY = 25;
@@ -60,7 +63,20 @@ function tail(label, width) {
     return `…${label.slice(-(width - 1))}`;
 }
 export function startProgress(title, opts) {
-    const write = opts?.write ?? ((s) => process.stdout.write(s));
+    /**
+     * O PROGRESSO VAI PARA `stderr`, como o banner de fase ao lado - e isto é o que torna a saída
+     * copiável com garantia, e não com esperança.
+     *
+     * Uma barra é PROGRESSO, não resultado. O banner de fase já seguia essa regra desde 01/08 pelo
+     * mesmo motivo; a barra tinha ficado no `stdout` por descuido. Com ela em `stderr`, `sync > arquivo`
+     * e `sync | pbcopy` entregam o relatório limpo sem depender de o terminal honrar `\x1b[2K` - e na
+     * tela nada muda, porque o terminal mostra os dois.
+     *
+     * O dono viu isso duas vezes: na primeira eram 2 172 quadros no clipboard, e na segunda, já com o
+     * limite de tempo, ainda sobravam mais de cem. Depender do comportamento do terminal de cada pessoa
+     * é depender do que a gente não controla.
+     */
+    const write = opts?.write ?? ((s) => process.stderr.write(s));
     const tty = opts?.isTty ?? Boolean(process.stdout.isTTY);
     const now = opts?.now ?? (() => Date.now());
     let total = opts?.total ?? 0;
@@ -68,12 +84,22 @@ export function startProgress(title, opts) {
     let last = "";
     /** `-Infinity` para o PRIMEIRO passo pintar sempre: silêncio no começo lê como travado. */
     let painted = Number.NEGATIVE_INFINITY;
+    /**
+     * APAGAR A LINHA, e não pintar espaços por cima dela.
+     *
+     * A versão anterior voltava o cursor com `\r` e escrevia 80 caracteres, sobrando espaços para cobrir
+     * o quadro mais longo. Na tela funciona; no clipboard não: o terminal do dono guardava cada escrita
+     * como conteúdo NOVO, então colar trazia os quadros um atrás do outro separados por corridas de
+     * espaço - foi exatamente o que ele mostrou depois do primeiro conserto (dono, 09/08).
+     *
+     * `\x1b[2K` é a instrução explícita de LIMPAR A LINHA. Um terminal que a honra substitui a linha no
+     * próprio buffer em vez de acrescentar, e aí a seleção pega uma linha só. E como não há mais nada a
+     * cobrir, o preenchimento some junto: menos 65 bytes por quadro, e nenhuma corrida de espaço no
+     * texto colado.
+     */
     const paint = () => {
         const count = total > 0 ? `${done} of ${total}` : String(done);
-        const line = `  ${bar(done, total)}  ${count}  ${tail(last, 40)}`;
-        // Pad to the previous width so a shorter label cannot leave the tail of a
-        // longer one behind on the line.
-        write(`\r${line.padEnd(80)}`);
+        write(`\x1b[2K\r  ${bar(done, total)}  ${count}  ${tail(last, 40)}`);
     };
     return {
         step(label) {
@@ -103,7 +129,7 @@ export function startProgress(title, opts) {
         },
         done(summary) {
             if (tty)
-                write(`\r${" ".repeat(80)}\r`);
+                write("\x1b[2K\r");
             if (summary)
                 write(`  ${summary}\n`);
         },

package/dist/repo-state.js

@@ -55,6 +55,7 @@ export async function repoStateOf(projectRoot, slug, cli) {
         ...(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)

package/package.json

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