synthesisui 0.16.445 → 0.16.446

package/dist/agent-wiring.js

@@ -1,6 +1,7 @@
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { hasCodexBlock, pinnedInCodex, withCodexBlock } from "./codex-mcp.js";
+import { wrapperSource } from "./statusline-wrapper.js";
 /**
  * QUANDO A CHECAGEM RODA - e por que `Bash` entrou em 12/09.
  *
@@ -326,6 +327,39 @@ async function wireCodexMcp(root) {
     await writeFile(path, next, "utf8");
     return had ? "updated" : "added";
 }
+/**
+ * A BARRA DE STATUS GANHA UM SEGMENTO, E A DELE CONTINUA INTEIRA - pedido do dono em 21/09:
+ * *"uma métrica um pouco na frente do Status que fale a quantidade de vezes que a gente
+ * sincronizou (...) se tiver alguma coisa lá, não mexe: mantém o que estava e adiciona"*.
+ *
+ * O `statusLine` do `.claude/settings.json` é DELE - no caso do dono, o Pulse, que vem do CodeLevel.
+ * Por isso não se substitui nada: o que se escreve é um invólucro que CHAMA o comando que estava lá
+ * e acrescenta o nosso segmento no fim. Se aquele comando cair, a barra dele ainda sai; se o ledger
+ * não puder ser lido, o segmento some e o resto fica.
+ *
+ * IDEMPOTENTE PELA MARCA: se o `statusLine` já aponta para o nosso arquivo, nada é reescrito - nem
+ * o `settings.json`, nem o invólucro, que guardaria o comando ERRADO se fosse regravado (ele já
+ * aponta para si mesmo, e o anterior se perderia).
+ */
+export async function wireStatusLine(root) {
+    const rel = "_synthesisui/statusline.mjs";
+    const ours = `node ${rel}`;
+    const dir = join(root, ".claude");
+    const path = join(dir, "settings.json");
+    const settings = await readJson(path);
+    const current = settings.statusLine;
+    const command = typeof current?.command === "string" ? current.command : "";
+    if (command.includes(rel))
+        return { status: "already there", command: ours };
+    const was = command.trim() ? command : null;
+    await mkdir(join(root, "_synthesisui"), { recursive: true });
+    await writeFile(join(root, rel), wrapperSource(was), "utf8");
+    await mkdir(dir, { recursive: true });
+    await writeFile(path, `${JSON.stringify({ ...settings, statusLine: { type: "command", command: ours } }, null, 2)}\n`, "utf8");
+    return was
+        ? { status: "wrapped", command: ours, was }
+        : { status: "added", command: ours };
+}
 export async function wireAgent(root, version, want) {
     /**
      * A ESCOLHA DELE DECIDE QUEM É FIADO (A2 da etapa 12) - ver `agents-chosen.ts`.
@@ -355,6 +389,14 @@ export async function wireAgent(root, version, want) {
             ? await wireSessionStart(root, await alignCommand(root, version))
             : "skipped",
         mcp: want.mcp ? await wireMcp(root, want.agents) : "skipped",
+        /**
+         * O SEGMENTO DA BARRA vai junto do resto da fiação do Claude Code, e pelo mesmo motivo: o
+         * `settings.json` é dele, e num repositório onde ele não escolheu o Claude Code escrever ali é
+         * plantar fiação que ninguém pediu.
+         */
+        statusLine: claude
+            ? await wireStatusLine(root)
+            : { status: "skipped", command: "" },
     };
 }
 /**

package/dist/statusline-wrapper.js

@@ -0,0 +1,105 @@
+/**
+ * A BARRA DELE CONTINUA SENDO A DELE, E A NOSSA INFORMAÇÃO ENTRA AO LADO - pedido do dono em
+ * 21/09: *"se tiver alguma coisa lá, ele não mexesse; mantivesse o que estava lá e adicionasse
+ * mais essa informação"*.
+ *
+ * O `statusLine` do `.claude/settings.json` costuma já ter um script - no caso dele, o Pulse, que é
+ * do CodeLevel. Trocar aquilo pelo nosso seria apagar a barra que ele construiu. Então o que a
+ * gente instala é um INVÓLUCRO: ele chama o comando que estava lá, pega a saída inteira e acrescenta
+ * o nosso segmento no fim da última linha.
+ *
+ * ═══ O QUE ESTE MÓDULO É ═══
+ *
+ * A função que gera o TEXTO do invólucro. Ela existe para o conteúdo do arquivo ser testável sem
+ * escrever em disco nem rodar um shell - o que o teste guarda é que o comando anterior é chamado e
+ * que a falha dele não derruba a barra.
+ */
+/** A marca que torna a instalação idempotente e a remoção segura. */
+export const WRAPPER_MARK = "synthesisui:statusline";
+/**
+ * O invólucro, como texto.
+ *
+ * `anterior` é o comando que já estava no `statusLine` - `null` quando não havia nenhum, e aí a
+ * barra passa a ser só o nosso segmento.
+ */
+export function wrapperSource(anterior) {
+    return `#!/usr/bin/env node
+/* ${WRAPPER_MARK} - managed by the synthesisui CLI. Delete this file to remove it.
+ *
+ * It runs YOUR status line and appends one segment: how many pulses today and in total.
+ * Your command is called first and its output is passed through untouched - if it fails,
+ * or if the count cannot be read, you still get your bar. A status line that disappears
+ * because a counter broke is worse than no counter.
+ */
+import { execSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const input = readFileSync(0, "utf8");
+const previous = ${anterior === null ? "null" : JSON.stringify(anterior)};
+
+let bar = "";
+if (previous) {
+  try {
+    /* DOIS SEGUNDOS, E O NÚMERO É AJUSTÁVEL: a barra redesenha o tempo todo, então esperar por ela
+       é pagar em travamento do terminal. Quem tem uma barra pesada afrouxa por env em vez de
+       perder o segmento - e o teste usa isso para não competir com a suíte inteira. */
+    const limit = Number(process.env.SYNTHESISUI_BAR_TIMEOUT_MS) || 2000;
+    bar = execSync(previous, { input, encoding: "utf8", timeout: limit });
+  } catch {
+    /* a barra dele caiu ou demorou: seguimos com o nosso segmento, nunca com a tela vazia */
+  }
+}
+
+let segment = "";
+try {
+  const dir = process.env.SYNTHESISUI_DIR ?? "_synthesisui";
+  const raw = readFileSync(join(process.cwd(), dir, "ledger.jsonl"), "utf8");
+  const lines = raw
+    .split("\\n")
+    .filter(Boolean)
+    .map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    });
+  /* A CONTAGEM VIAJA INLINE, e não como import: um segundo arquivo ao lado é mais uma peça para
+     sumir, e este script roda a cada respiração do terminal. A regra está em pulse-count.ts, com
+     os testes; aqui ela é a mesma condição, escrita uma vez. */
+  const FETCHING = new Set(["import", "add", "component", "template", "upgrade", "sync", "absorb", "refit"]);
+  const now = new Date();
+  let today = 0;
+  let total = 0;
+  for (const l of lines) {
+    if (!l || l.kind !== "run" || typeof l.command !== "string") continue;
+    if (l.ok === false || !FETCHING.has(l.command) || typeof l.at !== "string") continue;
+    const when = new Date(l.at);
+    if (Number.isNaN(when.getTime())) continue;
+    total += 1;
+    if (
+      when.getFullYear() === now.getFullYear() &&
+      when.getMonth() === now.getMonth() &&
+      when.getDate() === now.getDate()
+    )
+      today += 1;
+  }
+  /* Zero e zero não vira "0 · 0": não há o que dizer ainda, e um zero parece defeito. */
+  if (total > 0) segment = \`Pulls \${today} today · \${total}\`;
+} catch {
+  /* sem ledger ainda, ou ilegível: o segmento simplesmente não aparece */
+}
+
+if (!segment) {
+  process.stdout.write(bar);
+} else if (!bar.trim()) {
+  process.stdout.write(segment);
+} else {
+  /* No fim da ÚLTIMA linha: é lá que a barra dele termina, e é onde ele pediu - à frente do Status. */
+  const lines = bar.replace(/\\n$/, "").split("\\n");
+  lines[lines.length - 1] += " │ " + segment;
+  process.stdout.write(lines.join("\\n"));
+}
+`;
+}

package/package.json

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