synthesisui 0.16.177 → 0.16.179

package/dist/commands/add.js

@@ -25,21 +25,45 @@ import { detectStack } from "../stack.js";
  *
  * Escrito uma vez e nunca reescrito: um arquivo que alguém ajustou é decisão dele.
  */
+/**
+ * O que NÃO é do repositório: a medição e o registro local. Ambos são reescritos por inteiro a cada
+ * rodada e conflitariam em todo merge; o `.ledger-sent` descreve este clone e mais nada.
+ */
+const IGNORED = [
+    "census.json",
+    "ledger.jsonl",
+    ".ledger-sent",
+    "not-expressed.md",
+];
+const IGNORE_HEADER = "# Managed by synthesisui. The identity and the CSS are committed so a fresh\n" +
+    "# clone is governed; the measurement and the local record are not, because\n" +
+    "# both are rewritten in full on every run and would conflict on every merge.\n";
 async function writeGovernanceIgnore(projectRoot) {
     const path = join(projectRoot, "_synthesisui", ".gitignore");
-    try {
-        await access(path);
+    const existing = await readFile(path, "utf8").catch(() => null);
+    /**
+     * O ARQUIVO DIZ "Managed by synthesisui", E ELE PRECISA SER.
+     *
+     * Isto saía na primeira linha quando o arquivo já existia, então ele era escrito UMA vez e nunca
+     * mais. A consequência aparece na primeira vez que a gente acrescenta um registro local: em 07/08
+     * nasceu o `.ledger-sent`, e todo repositório que já tinha o `.gitignore` passaria a commitar um
+     * cursor que descreve a máquina de UMA pessoa. Um arquivo que se declara gerenciado e não é
+     * reconciliado é uma promessa quebrada com o time de alguém.
+     *
+     * ACRESCENTA, NUNCA REMOVE: uma linha que a pessoa escreveu ali é decisão dela, e some no dia em
+     * que a gente reescrevesse o arquivo inteiro. E só grava quando falta algo - um comando que sempre
+     * produz diff é um comando que o time para de rodar.
+     */
+    if (existing == null) {
+        await writeFile(path, `${IGNORE_HEADER}${IGNORED.map((l) => `${l}\n`).join("")}`, "utf8");
         return;
     }
-    catch {
-        // não existe - escrever
-    }
-    await writeFile(path, "# Managed by synthesisui. The identity and the CSS are committed so a fresh\n" +
-        "# clone is governed; the measurement and the local record are not, because\n" +
-        "# both are rewritten in full on every run and would conflict on every merge.\n" +
-        "census.json\n" +
-        "ledger.jsonl\n" +
-        "not-expressed.md\n", "utf8");
+    const lines = new Set(existing.split("\n").map((l) => l.trim()));
+    const missing = IGNORED.filter((l) => !lines.has(l));
+    if (missing.length === 0)
+        return;
+    const sep = existing.endsWith("\n") ? "" : "\n";
+    await writeFile(path, `${existing}${sep}${missing.map((l) => `${l}\n`).join("")}`, "utf8");
 }
 /**
  * APAGA A PROSA QUE ESTA VERSÃO DEIXOU DE ESCREVER.

package/dist/commands/align.js

@@ -2,7 +2,7 @@ import { readdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { readToken, resolveRegistry } from "../config.js";
-import { readEvents } from "../doctor/ledger.js";
+import { unsentEvents } from "../doctor/ledger.js";
 import { measuredScope } from "../measured-scope.js";
 import { READER } from "../reader-version.js";
 /**
@@ -124,7 +124,12 @@ opts = {}) {
              */
             run: "npx synthesisui sync",
         });
-    const events = await readEvents(root).catch(() => []);
+    /**
+     * SÓ O QUE NÃO SUBIU - ver `unsentEvents`. Isto contava o arquivo inteiro, e como o ledger é
+     * append-only e o `sync` manda tudo (a plataforma deduplica), a linha nunca mais saía da tela e o
+     * número só crescia.
+     */
+    const events = await unsentEvents(root).catch(() => []);
     if (events.length > 0)
         out.push({
             says: `${events.length} checked write${events.length === 1 ? "" : "s"} recorded here and not sent - the platform is scoring this repo on older evidence.`,

package/dist/commands/sync.js

@@ -1,7 +1,7 @@
 import { readdir, readFile, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { readToken, resolveRegistry } from "../config.js";
-import { readEvents } from "../doctor/ledger.js";
+import { markSent, readEvents } from "../doctor/ledger.js";
 import { checkableName, closeRequest, readRequests, verifyAndCloseRequests, } from "../doctor/requests.js";
 import { measuredScope, rememberScope } from "../measured-scope.js";
 import { body, paint, section, snippet } from "../output.js";
@@ -114,6 +114,11 @@ export async function sync(opts) {
         console.log(body(err.message ?? `The registry answered ${res.status}.`));
         return;
     }
+    /**
+     * O QUE SUBIU, ANOTADO - senão o `align` continua pedindo o envio do que acabou de ser enviado.
+     * Depois da resposta OK, e nunca antes: marcar um envio que falhou perderia os eventos de vez.
+     */
+    await markSent(root, events);
     const out = (await res.json());
     console.log(section("Sync"));
     console.log(body(`${out.eventsReceived} checks sent, ${out.eventsNew} new. ${out.requestsNow} open request${out.requestsNow === 1 ? "" : "s"}.`));

package/dist/doctor/ledger.js

@@ -46,6 +46,55 @@ export async function appendEvent(root, event) {
         // is a ledger that gets the hook uninstalled.
     }
 }
+/**
+ * ATÉ ONDE ESTE REPO JÁ MANDOU - e a ausência disto fazia o `align` mentir para sempre.
+ *
+ * O ledger é APPEND-ONLY e o `sync` manda o arquivo inteiro; a plataforma deduplica (em 07/08 uma
+ * rodada reportou "6 checks sent, 1 new"). Só que o `align` contava TODAS as linhas e dizia "6
+ * checked writes recorded here and not sent" - sobre cinco que tinham subido minutos antes. O número
+ * só crescia, então aquela linha nunca mais sairia da tela, e um aviso permanente é um aviso que a
+ * pessoa aprende a pular (dono, 07/08: *"quer apostar que você vai achar algo errado?"*).
+ *
+ * A CONTAGEM E A HORA, as duas: a contagem responde sozinha enquanto o arquivo só cresce, e a hora
+ * dá como perceber que ele foi trocado por outro - aí a contagem antiga não vale mais nada.
+ */
+const SENT_FILE = ".ledger-sent";
+const sentPath = (root) => join(root, "_synthesisui", SENT_FILE);
+export async function readSent(root) {
+    const raw = await readFile(sentPath(root), "utf8").catch(() => "");
+    if (!raw)
+        return { count: 0 };
+    try {
+        const v = JSON.parse(raw);
+        return {
+            count: typeof v.count === "number" && v.count >= 0 ? v.count : 0,
+            ...(typeof v.at === "string" ? { at: v.at } : {}),
+        };
+    }
+    catch {
+        return { count: 0 };
+    }
+}
+export async function markSent(root, events) {
+    const last = events[events.length - 1]?.at;
+    await writeFile(sentPath(root), `${JSON.stringify({ count: events.length, ...(last ? { at: last } : {}) })}\n`, "utf8").catch(() => {
+        /** O registro nunca pode custar o envio: o pior caso é o aviso reaparecer uma vez. */
+    });
+}
+/**
+ * Os eventos que este repo ainda não mandou.
+ *
+ * Se a contagem gravada é maior que o arquivo, alguém o trocou ou apagou - e aí a marca não descreve
+ * mais este arquivo. Contar tudo de novo é a leitura honesta: um envio a mais custa nada, e a
+ * plataforma deduplica.
+ */
+export async function unsentEvents(root) {
+    const all = await readEvents(root);
+    const { count } = await readSent(root);
+    if (count <= 0 || count > all.length)
+        return all;
+    return all.slice(count);
+}
 export async function readEvents(root) {
     const raw = await readFile(ledgerPath(root), "utf8").catch(() => "");
     if (!raw)

package/package.json

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