synthesisui 0.16.429 → 0.16.430

package/dist/commands/add.js

@@ -47,6 +47,12 @@ const IGNORED = [
     /** O que a última medição viu, para a próxima dizer o que mudou - descreve ESTE clone. */
     ".last-sync.json",
     "not-expressed.md",
+    /**
+     * O RELATÓRIO QUE O `inspect` ESCREVE - a leitura inteira com forma, para ele abrir no navegador.
+     * Mesma natureza do censo: é a MEDIÇÃO, reescrita por inteiro a cada rodada, então versioná-la é
+     * conflito toda vez e ainda poria um HTML de meio megabyte no diff de quem só rodou o comando.
+     */
+    "report.html",
     /**
      * O MODO DELA - ver `mode.ts`. Commitado, ele barraria o time inteiro porque UMA pessoa ligou
      * o bloqueio dela, e o aceite da etapa 06 é literal: *"a escolha de uma pessoa nunca barra
@@ -78,7 +84,12 @@ export async function ensureGovernanceHome(projectRoot) {
     await mkdir(join(projectRoot, "_synthesisui"), { recursive: true });
     await writeGovernanceIgnore(projectRoot);
 }
-async function writeGovernanceIgnore(projectRoot) {
+/**
+ * EXPORTADO desde 18/09 porque o `inspect` passou a escrever um arquivo na pasta: o relatório. Um
+ * comando de primeiro contato que deixa um HTML de 30 KB aparecendo no `git status` de quem só quis
+ * olhar cobra da pessoa uma limpeza que ela não pediu - e a pasta já é declarada gerenciada aqui.
+ */
+export async function writeGovernanceIgnore(projectRoot) {
     const path = join(projectRoot, "_synthesisui", ".gitignore");
     const existing = await readFile(path, "utf8").catch(() => null);
     /**

package/dist/commands/import.js

@@ -55,12 +55,14 @@ import { body, bodyWrapped, paint, section } from "../output.js";
 import { consumersOf, outsideScope, } from "../outside-scope.js";
 import { phase, startProgress } from "../progress.js";
 import { repoStateOf } from "../repo-state.js";
+import { relatorioHtml, secoesDe } from "../report-html.js";
 import { runtimeDeclaredVars, runtimeDeclaredVarsIn } from "../runtime-vars.js";
 import { detectStack, resolveDeps, stackVersions } from "../stack.js";
+import { desligarCaptura, ligarCaptura } from "../transcript.js";
 import { wiredSlugs, wiringWarning } from "../wired-slugs.js";
 import { harvestWorkspaceCss } from "../workspace-css.js";
 import { placeInWorkspace } from "../workspace-place.js";
-import { add } from "./add.js";
+import { add, writeGovernanceIgnore } from "./add.js";
 import { walk, walkAll } from "./doctor.js";
 /**
  * UMA PÁGINA DELE, como ele a montou - ver `Census.pages`.
@@ -3720,6 +3722,145 @@ export function defaultScheme(declared) {
     return dark > light ? "dark" : "light";
 }
 /** On a dry run there is nobody to ask, so say what was measured. */
+/**
+ * A TELA DO `inspect`, E O ARQUIVO QUE CARREGA O RESTO (dono, 18/09).
+ *
+ * O QUE O CLIENTE GANHA: ele decide sem rolar. Ficam na tela os quatro blocos que MUDAM o que ele
+ * vai fazer em seguida - quanto foi lido, se o root tem mais de um app, o que não resolve, e onde
+ * está a leitura inteira. Medido na saída dele em 18/09: 250 linhas, 94 delas a mesma frase sobre
+ * nome de parte. Nada se perde: o texto inteiro está no relatório, escrito pela MESMA esteira.
+ *
+ * A FRASE DO CONTRATO MUDA, E É A ÚNICA COISA QUE MUDA: era "nothing was written, and nothing was
+ * sent". Passa a dizer a verdade - nada enviado, um arquivo escrito, e aqui está ele. Uma frase que
+ * promete silêncio enquanto o comando escreve um arquivo é pior que o arquivo.
+ */
+async function mostrarInspecao(c, root, transcrito) {
+    const secoes = secoesDe(transcrito);
+    const valores = c.values?.classes;
+    const decisoes = valores ? valores.seen - valores.structure : 0;
+    const pct = valores && decisoes > 0
+        ? Math.round((valores.interpreted / decisoes) * 100)
+        : null;
+    const lidos = c.coverage?.read ?? 0;
+    const total = c.coverage?.components ?? 0;
+    const arquivo = join(root, "_synthesisui", "report.html");
+    const html = () => relatorioHtml({
+        cabecalho: {
+            repo: c.measured?.repo ?? basename(root),
+            medidoEm: c.measured?.at ?? "",
+            cli: c.ledger?.cli ?? "",
+        },
+        destaques: [
+            {
+                numero: `${lidos} of ${total}`,
+                rotulo: "components came out with a blueprint",
+            },
+            ...(pct === null
+                ? []
+                : [
+                    {
+                        numero: `${pct}%`,
+                        rotulo: `of ${decisoes} style decisions carry your vocabulary`,
+                    },
+                ]),
+            {
+                numero: String(c.brokenRefs?.length ?? 0),
+                rotulo: "references that resolve to nothing",
+            },
+        ],
+        secoes,
+    });
+    console.log(section("What came out of your files"));
+    console.log(body(`${paint.strong(`${lidos} of ${total}`)} components came out with a blueprint${pct === null
+        ? ""
+        : `, and ${paint.strong(`${pct}%`)} of your ${decisoes} style decisions carry your own vocabulary`}.`));
+    /**
+     * OS DOIS BLOCOS QUE MUDAM O QUE ELE FAZ EM SEGUIDA, e eles saem do transcrito em vez de serem
+     * reescritos: a régua que os produziu é a mesma, então a tela nunca diverge do relatório.
+     */
+    for (const titulo of DECIDEM) {
+        const achada = secoes.find((s) => s.titulo === titulo);
+        if (!achada)
+            continue;
+        console.log(section(titulo));
+        for (const linha of achada.linhas)
+            console.log(linha);
+    }
+    /**
+     * O ARQUIVO SÓ NASCE SE ELE PEDIR (dono, 18/09) - e é isto que mantém `INV-INSPECT-01` de pé.
+     *
+     * A promessa que faz alguém rodar este comando sem medo é que nada acontece: ele lê, mostra, e
+     * o repositório continua exatamente como estava. Escrever o relatório por conta própria
+     * quebraria isso para TODO mundo, inclusive para quem só queria olhar - e num primeiro contato
+     * essa é a confiança inteira. Perguntando, a escrita deixa de ser nossa e passa a ser dele.
+     *
+     * SEM TERMINAL, NÃO PERGUNTA E NÃO ESCREVE: um `inspect` dentro de um pipe, de um CI ou de um
+     * agente não tem quem responda, e um default que escreve seria a mesma quebra por outra porta.
+     * É a mesma guarda que `askName` já usa.
+     */
+    console.log(section("The whole reading, in one file"));
+    console.log(body(`${secoes.length} sections did not print here - every value, every fragment, every part.`));
+    console.log(body(paint.faint("A single self-contained page in your project. Nothing is sent either way.")));
+    if (!(await quer(`    write the full report? [Y/n]: `))) {
+        console.log("");
+        console.log(body("Nothing was written, and nothing was sent."));
+        console.log("");
+        console.log(body("To let your agent ask before it invents:"));
+        console.log(body(`    ${paint.strong("npx synthesisui@latest connect")}`));
+        console.log("");
+        return;
+    }
+    await mkdir(dirname(arquivo), { recursive: true });
+    /**
+     * A PASTA SE DECLARA GERENCIADA ANTES DE RECEBER O ARQUIVO: sem isto, o HTML apareceria no
+     * `git status` de quem acabou de pedir um relatório, e não um arquivo versionado.
+     */
+    await writeGovernanceIgnore(root).catch(() => null);
+    await writeFile(arquivo, html(), "utf8");
+    console.log("");
+    console.log(body(`    ${paint.strong(relative(root, arquivo))}`));
+    console.log(body(`    ${paint.dim(`file://${arquivo}`)}`));
+    console.log("");
+    console.log(body("To let your agent ask before it invents:"));
+    console.log(body(`    ${paint.strong("npx synthesisui@latest connect")}`));
+    console.log("");
+}
+/**
+ * A PERGUNTA DE UMA TECLA, e o silêncio de quem não tem terminal.
+ *
+ * Fora de um terminal a resposta é NÃO, sempre: ninguém está lá para responder, e assumir o sim
+ * escreveria no repositório de um CI que só queria ler. Enter é sim porque a pessoa acabou de ler
+ * a oferta na linha acima - exigir uma letra para receber o que a tela ofereceu é atrito sem
+ * proteção nenhuma.
+ */
+async function quer(pergunta) {
+    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 {
+        console.log("");
+        const resposta = (await rl.question(pergunta)).trim().toLowerCase();
+        return resposta === "" || resposta === "y" || resposta === "yes";
+    }
+    catch {
+        return false;
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * AS SEÇÕES QUE CONTINUAM NA TELA, e o critério é um só: elas mudam o comando seguinte.
+ *
+ * Um root com três apps mede a média de três paletas, o que é diagnóstico e não sistema - e a saída
+ * já traz o `--scope`/`--usage` exato. Um `var()` que não resolve não pinta cor nenhuma no
+ * navegador dele. As outras quinze seções descrevem; estas duas pedem uma decisão.
+ */
+const DECIDEM = [
+    "This root holds several projects",
+    "These resolve to nothing",
+];
 function sayReach(c) {
     const reach = ladderReach(c.declared);
     console.log("");
@@ -4332,6 +4473,16 @@ export async function runImport(opts) {
         if (!opts.inspect)
             phase(1, 3, "Measuring the repository");
         console.log(section("Reading your project"));
+        /**
+         * A PARTIR DAQUI O `inspect` GUARDA EM VEZ DE IMPRIMIR - ver `transcript.ts`.
+         *
+         * As dezessete seções continuam sendo escritas exatamente como sempre foram; o que muda é o
+         * destino. Elas vão para o relatório, e o terminal fica com os quatro blocos que uma pessoa
+         * usa para DECIDIR. Medido na saída do `codelevel-monorepo` em 18/09: 250 linhas, das quais 94
+         * eram a mesma frase sobre nome de parte - 40% do relatório num detalhe sem ação possível.
+         */
+        if (opts.inspect)
+            ligarCaptura();
         /**
          * UMA MEDIÇÃO POR ESCOPO, E DEPOIS A FUSÃO.
          *
@@ -4448,13 +4599,8 @@ export async function runImport(opts) {
      */
     if (opts.inspect) {
         sayReach(census);
-        console.log("");
-        console.log(section("Your agent cannot ask any of this yet"));
-        console.log(body("Nothing was written, and nothing was sent."));
-        console.log("");
-        console.log(body("To let it ask before it invents:"));
-        console.log(body(`    ${paint.strong("npx synthesisui@latest connect")}`));
-        console.log("");
+        const transcrito = desligarCaptura();
+        await mostrarInspecao(census, root, transcrito);
         return;
     }
     const out = opts.census ?? join(root, "_synthesisui", "census.json");

package/dist/report-html.js

@@ -0,0 +1,205 @@
+import { semCor } from "./transcript.js";
+/**
+ * O QUE O TERMINAL DIRIA, LIDO DE VOLTA COMO DOCUMENTO.
+ *
+ * A régua `── Título ──────` é a única marca estrutural que a saída tem, e ela é desenhada num
+ * lugar só (`section`), então é ela que separa os capítulos. Tudo antes da primeira régua é ruído
+ * de progresso e não entra: o documento começa no primeiro capítulo, não no meio do carregamento.
+ */
+export function secoesDe(linhas) {
+    const secoes = [];
+    for (const bruta of linhas) {
+        for (const linha of semCor(bruta).split("\n")) {
+            const cabeca = /^──\s(.+?)\s─*$/.exec(linha.trimEnd());
+            if (cabeca) {
+                secoes.push({ titulo: cabeca[1].trim(), linhas: [] });
+                continue;
+            }
+            if (secoes.length === 0)
+                continue;
+            secoes[secoes.length - 1].linhas.push(linha.replace(/\s+$/, ""));
+        }
+    }
+    /** Capítulo que não disse nada não vira capítulo - uma régua sozinha não é conteúdo. */
+    return secoes
+        .map((s) => ({ ...s, linhas: aparar(s.linhas) }))
+        .filter((s) => s.linhas.length > 0);
+}
+/** Tira as linhas em branco das pontas, e nunca as do meio - lá elas são respiro. */
+function aparar(linhas) {
+    let i = 0;
+    let f = linhas.length;
+    while (i < f && linhas[i].trim() === "")
+        i += 1;
+    while (f > i && linhas[f - 1].trim() === "")
+        f -= 1;
+    return linhas.slice(i, f);
+}
+function escapar(s) {
+    return s
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+export function relatorioHtml(input) {
+    const { cabecalho, destaques, secoes } = input;
+    const quando = legivel(cabecalho.medidoEm);
+    const indice = secoes
+        .map((s, i) => `<li><a href="#s${i}">${escapar(s.titulo)}</a></li>`)
+        .join("\n        ");
+    const corpo = secoes
+        .map((s, i) => `      <section id="s${i}">
+        <h2>${escapar(s.titulo)}</h2>
+        <pre>${escapar(s.linhas.join("\n"))}</pre>
+      </section>`)
+        .join("\n");
+    const numeros = destaques
+        .map((d) => `        <div class="stat">
+          <strong>${escapar(d.numero)}</strong>
+          <span>${escapar(d.rotulo)}</span>
+        </div>`)
+        .join("\n");
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapar(cabecalho.repo)} - read by SynthesisUI</title>
+<style>
+${estilo()}
+</style>
+</head>
+<body>
+  <header>
+    <p class="kicker">Read by SynthesisUI</p>
+    <h1>${escapar(cabecalho.repo)}</h1>
+    <p class="meta">Read ${escapar(quando)} by CLI ${escapar(cabecalho.cli)} &middot; nothing left this machine</p>
+  </header>
+
+  <div class="wrap">
+    <div class="stats">
+${numeros}
+    </div>
+
+    <nav>
+      <p class="kicker">What is in here</p>
+      <ol>
+        ${indice}
+      </ol>
+    </nav>
+
+    <main>
+${corpo}
+    </main>
+
+    <footer>
+      <p>This file lives in your project and was never sent anywhere. Re-run the command to refresh it.</p>
+    </footer>
+  </div>
+</body>
+</html>
+`;
+}
+/** A data em palavras. Data ilegível some da frase em vez de imprimir `Invalid Date`. */
+function legivel(iso) {
+    if (!iso || Number.isNaN(Date.parse(iso)))
+        return "just now";
+    return new Date(iso).toLocaleDateString("en-US", {
+        month: "short",
+        day: "numeric",
+        year: "numeric",
+    });
+}
+/**
+ * A FOLHA, E ELA É INTEIRA DAQUI: nenhuma família remota, nenhum reset de terceiro. As famílias são
+ * as genéricas do sistema de quem abrir, porque baixar uma fonte para desenhar um relatório sobre o
+ * repositório de alguém contradiz o comando que não manda nada para lugar nenhum.
+ *
+ * E ela imprime: `@media print` existe porque o navegador já exporta PDF, e um relatório que sai
+ * torto no papel obriga a construir um gerador de PDF para resolver o que uma regra resolve.
+ */
+function estilo() {
+    return `:root {
+  color-scheme: light dark;
+  --ink: #16161a;
+  --ink-soft: #55555f;
+  --line: #e4e4e9;
+  --paper: #ffffff;
+  --canvas: #f6f6f8;
+  --accent: #b4530a;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --ink: #edecea;
+    --ink-soft: #a0a0aa;
+    --line: #2a2a31;
+    --paper: #17171b;
+    --canvas: #0f0f12;
+    --accent: #e9a13b;
+  }
+}
+* { box-sizing: border-box; }
+body {
+  margin: 0;
+  background: var(--canvas);
+  color: var(--ink);
+  font: 15px/1.6 ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif;
+}
+header {
+  padding: 56px 24px 40px;
+  border-bottom: 1px solid var(--line);
+  background: var(--paper);
+}
+.wrap, header > * { max-width: 900px; margin-inline: auto; }
+.wrap { padding: 0 24px 72px; }
+.kicker {
+  margin: 0;
+  font: 600 11px/1.4 ui-monospace, SFMono-Regular, Menlo, monospace;
+  letter-spacing: 0.16em;
+  text-transform: uppercase;
+  color: var(--accent);
+}
+h1 { margin: 12px 0 8px; font-size: 34px; line-height: 1.15; letter-spacing: -0.02em; }
+.meta { margin: 0; color: var(--ink-soft); font-size: 14px; }
+.stats {
+  display: grid;
+  gap: 12px;
+  grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+  margin: -28px 0 40px;
+}
+.stat {
+  background: var(--paper);
+  border: 1px solid var(--line);
+  border-radius: 14px;
+  padding: 18px 20px;
+}
+.stat strong { display: block; font-size: 26px; letter-spacing: -0.02em; }
+.stat span { display: block; margin-top: 4px; color: var(--ink-soft); font-size: 13px; }
+nav { margin-bottom: 40px; }
+nav ol { margin: 10px 0 0; padding-left: 20px; color: var(--ink-soft); }
+nav li { margin: 3px 0; }
+nav a { color: inherit; }
+nav a:hover { color: var(--accent); }
+section {
+  background: var(--paper);
+  border: 1px solid var(--line);
+  border-radius: 14px;
+  padding: 22px 24px;
+  margin-bottom: 16px;
+}
+h2 { margin: 0 0 12px; font-size: 17px; letter-spacing: -0.01em; }
+pre {
+  margin: 0;
+  white-space: pre-wrap;
+  word-break: break-word;
+  font: 12.5px/1.65 ui-monospace, SFMono-Regular, Menlo, monospace;
+  color: var(--ink-soft);
+}
+footer { margin-top: 40px; color: var(--ink-soft); font-size: 13px; }
+@media print {
+  body { background: #fff; }
+  .stat, section { break-inside: avoid; border-color: #ddd; }
+  nav { display: none; }
+}`;
+}

package/dist/transcript.js

@@ -0,0 +1,50 @@
+/**
+ * O QUE O TERMINAL TERIA IMPRIMIDO, GUARDADO EM VEZ DE MOSTRADO.
+ *
+ * O QUE O CLIENTE GANHA: a saída do `inspect` volta a caber numa tela, e nada do que ela dizia se
+ * perde - o texto inteiro vai para o relatório que ele abre quando quiser.
+ *
+ * POR QUE AQUI E NÃO EM CADA IMPRESSOR: são dezessete seções escritas em dezessete lugares, e a
+ * leitura delas é a mesma coisa que a esteira já sabe dizer. Reescrevê-las num gerador de HTML
+ * criaria duas redações da mesma medição - e no dia em que uma fosse editada, o relatório passaria
+ * a afirmar algo que o terminal não afirma mais. Capturando, existe UMA fonte: o que a esteira diz.
+ *
+ * ELE É DELIBERADAMENTE BURRO: liga, guarda, desliga. Sem filtro, sem formatação e sem saber o que
+ * é seção - quem entende do assunto é quem transforma isto em documento.
+ */
+let guardadas = null;
+let originalLog = null;
+/**
+ * A REDE DE SEGURANÇA, e ela existe por um motivo específico: uma medição que lança no meio
+ * deixaria o `console.log` desviado pelo resto do processo, e a pessoa veria o comando morrer sem
+ * uma linha de explicação. O terminal volta ao normal mesmo quando ninguém se lembra de desligar.
+ */
+process.once("exit", () => {
+    if (originalLog)
+        console.log = originalLog;
+});
+/** Começa a guardar em vez de imprimir. Chamar duas vezes não empilha - a segunda é um no-op. */
+export function ligarCaptura() {
+    if (guardadas)
+        return;
+    guardadas = [];
+    originalLog = console.log;
+    console.log = (...args) => {
+        guardadas?.push(args.map((a) => (typeof a === "string" ? a : String(a))).join(" "));
+    };
+}
+/** Devolve o terminal a quem é dele, e entrega o que foi guardado. */
+export function desligarCaptura() {
+    const linhas = guardadas ?? [];
+    if (originalLog)
+        console.log = originalLog;
+    guardadas = null;
+    originalLog = null;
+    return linhas;
+}
+/** O caractere de escape ANSI, montado por código para não viajar cru no arquivo. */
+const ESC = String.fromCharCode(27);
+/** Tira a cor: o que vai para um arquivo não carrega sequência de escape de terminal. */
+export function semCor(line) {
+    return line.split(new RegExp(`${ESC}\\[[0-9;]*m`)).join("");
+}

package/package.json

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