synthesisui 0.16.170 → 0.16.172

package/dist/commands/align.js

@@ -156,11 +156,21 @@ export async function versionBehind(root, opts = {}) {
  * injetado no contexto de um agente, e cada linha decorativa é contexto que não é sobre o trabalho
  * dele.
  */
-export function describeMisalignments(items) {
+export function describeMisalignments(items, 
+/**
+ * DE ONDE A PERGUNTA VEIO decide a primeira frase, e não é enfeite.
+ *
+ * "Before this session starts" descreve o hook do editor. Num terminal não existe sessão nenhuma
+ * para começar, e a frase vira ruído em cima de um aviso que a pessoa precisa ler - o gancho de
+ * shell nasceu em 07/08 e a copy tinha que nascer com ele.
+ */
+from = "session") {
     if (items.length === 0)
         return "";
     return [
-        "Before this session starts, this environment is out of alignment with the design system that governs it:",
+        from === "shell"
+            ? "This repo is out of alignment with the design system that governs it:"
+            : "Before this session starts, this environment is out of alignment with the design system that governs it:",
         ...items.map((m) => `  - ${m.says}${m.run ? `\n      ${m.run}` : ""}`),
     ].join("\n");
 }
@@ -180,7 +190,7 @@ export async function align(opts) {
     const remote = await versionBehind(root).catch(() => null);
     if (remote)
         items.push(remote);
-    const text = describeMisalignments(items);
+    const text = describeMisalignments(items, opts.shell ? "shell" : "session");
     if (text)
         console.log(text);
 }

package/dist/commands/connect.js

@@ -3,6 +3,7 @@ import { dirname, join } from "node:path";
 import { wireAgent } from "../agent-wiring.js";
 import { blockHomes, syncClaudeMd } from "../claude-md.js";
 import { body, paint, section, snippet } from "../output.js";
+import { hasHook, rcPathFor, shellFrom, shellSnippet, withHook, } from "../shell-hook.js";
 import { IMPORT_SKILL, IMPORT_SKILL_PATH } from "../skill-import.js";
 import { INIT_SKILL, INIT_SKILL_PATH } from "../skill-init.js";
 import { add } from "./add.js";
@@ -81,6 +82,59 @@ async function refreshInstall(root, cli, registry) {
     }
     return null;
 }
+/**
+ * O AVISO NO TERMINAL, oferecido uma vez - ver `shell-hook.ts` para o porquê e as três restrições.
+ *
+ * FORA DO REPOSITÓRIO É OUTRO TERRITÓRIO. Tudo que o `connect` escreve hoje mora no projeto, e um
+ * `.zshrc` é da PESSOA e de todos os outros projetos dela. Então isto pergunta, mostra exatamente o
+ * que vai escrever e onde, e um "não" não custa nada: o hook do editor continua valendo inteiro.
+ *
+ * Sem TTY (CI, um agente rodando o comando) não há a quem perguntar, e a resposta certa é não
+ * escrever - um pipeline não deveria acordar com o perfil de shell de alguém alterado.
+ */
+async function offerShellHook(asked) {
+    const shell = shellFrom(process.env);
+    if (!shell)
+        return;
+    const rc = rcPathFor(shell);
+    const current = await readFile(rc, "utf8").catch(() => null);
+    /** Já instalado: re-materializa em silêncio, para uma melhoria no bloco alcançar quem já disse sim. */
+    if (current != null && hasHook(current)) {
+        const next = withHook(current, shellSnippet(shell));
+        if (next !== current) {
+            await writeFile(rc, next, "utf8").catch(() => { });
+            console.log("");
+            console.log(body(`Refreshed the terminal check in ${rc}.`));
+        }
+        return;
+    }
+    /** `--shell` é alguém que já decidiu - perguntar de novo seria não ter escutado. */
+    if (asked) {
+        await writeFile(rc, withHook(current ?? "", shellSnippet(shell)), "utf8");
+        console.log("");
+        console.log(body(`Terminal check written to ${rc}.`));
+        console.log(body(`Open a new terminal, or run: source ${rc}`));
+        return;
+    }
+    console.log("");
+    console.log(body("Your editor tells you when this repo drifts, once a session. Your terminal does not, and that is where most people notice something is stale."));
+    console.log(body(paint.faint(`Adding it writes one block to ${rc}. It stays silent when nothing is wrong, never blocks your prompt, and checks at most once an hour.`)));
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        console.log(body(paint.blue("  npx synthesisui@latest connect --shell")));
+        return;
+    }
+    const { createInterface } = await import("node:readline/promises");
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const answer = await rl.question(`  Add it to ${rc}? [y/N] `).catch(() => "");
+    rl.close();
+    if (!/^y(es)?$/i.test(answer.trim()))
+        return;
+    await writeFile(rc, withHook(current ?? "", shellSnippet(shell)), "utf8");
+    console.log(body(`Written. Open a new terminal, or run: source ${rc}`));
+}
 export async function connect(opts) {
     const root = opts.dir ?? process.cwd();
     // Both unless one is explicitly turned off - somebody who says `--no-hook`
@@ -228,6 +282,7 @@ export async function connect(opts) {
         console.log(body(paint.dim("Your PRs can carry this too: annotations on the exact line, and a ratchet that fails only when drift goes UP - never on the debt you already have.")));
         console.log(paint.blue(snippet(["npx synthesisui@latest ci"])));
     }
+    await offerShellHook(opts.shell === true);
     // The step that cost a round trip the first time this was tried by hand,
     // and would cost every single person one.
     console.log("");

package/dist/commands/sync.js

@@ -1,4 +1,4 @@
-import { readdir, readFile } from "node:fs/promises";
+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";
@@ -248,6 +248,18 @@ export async function remeasure(args) {
     if (stored.reading)
         census.reading = stored.reading;
     await resolveReadParts(census, root).catch(() => { });
+    /**
+     * O CENSO FRESCO TAMBÉM FICA NO DISCO.
+     *
+     * O `sync` media, mandava, e não reescrevia `_synthesisui/census.json` - só o `import` escreve. O
+     * resultado é a plataforma com a medição de hoje e o disco com a de três dias atrás, e TRÊS
+     * comandos locais lendo a velha: `gaps`, `summary`, e a resolução de escopo. Medido em 07/08 no repo
+     * do dono: o arquivo era de 06/08 depois de dois syncs (dono, 07/08).
+     *
+     * Duas cópias da mesma medição que discordam é a família de bug que este repo mais pagou este ano.
+     * Falhar aqui não derruba a rodada: o que importava - o envio - já aconteceu.
+     */
+    await writeFile(join(root, "_synthesisui", "census.json"), `${JSON.stringify(census, null, 2)}\n`, "utf8").catch(() => { });
     /**
      * O AVISO, ANTES DE ENVIAR. `edited` são as receitas que uma pessoa escreveu na tela; o cruzamento
      * com o que acabou de ser medido é uma interseção de conjuntos, e é por isso que ele mora aqui em

package/dist/index.js

@@ -246,6 +246,7 @@ async function main() {
                 hook: flags.hook !== false,
                 mcp: flags.mcp !== false,
                 ci: flags.ci === true,
+                shell: flags.shell === true,
             });
             return;
         case "hook":
@@ -555,7 +556,7 @@ async function main() {
          * `align.ts` para os nove estados e por que sete deles não tinham verificação nenhuma.
          */
         case "align":
-            await align({ dir, cli: CLI_VERSION });
+            await align({ dir, cli: CLI_VERSION, shell: flags.shell === true });
             break;
         case "request": {
             // `synthesisui request` lists; `request component --name x --for "..."`

package/dist/shell-hook.js

@@ -0,0 +1,100 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * O AVISO NO TERMINAL, e não só quando o agente abre.
+ *
+ * O `align` roda como `SessionStart` do editor, o que cobre o momento em que alguém vai trabalhar COM
+ * o agente. Não cobre o momento em que a maioria das pessoas percebe que algo está velho, que é abrir
+ * o terminal e dar `cd` no projeto (dono, 07/08). Entre um e outro cabe um dia inteiro de trabalho
+ * sobre um design system desatualizado - foi exatamente o que aconteceu com a v2 dele.
+ *
+ * TRÊS RESTRIÇÕES, e as três vieram de medir em vez de supor:
+ *
+ *   4 segundos     é o que um `align` custa através do npx. Rodar em primeiro plano transformaria
+ *                  todo `cd` numa espera, então o gancho joga para segundo plano e nunca segura o
+ *                  prompt.
+ *   uma vez por    sem trava, entrar e sair de uma pasta dispararia uma chamada de rede por vez. O
+ *   hora           carimbo mora em `~/.cache/synthesisui`, FORA do repositório - um arquivo de
+ *                  controle nosso dentro do projeto de alguém vira linha no `git status` dela.
+ *   silêncio       o `align` já não imprime nada quando está tudo certo, e é isso que faz um aviso
+ *                  continuar sendo lido no dia em que importa.
+ *
+ * O bloco é DELIMITADO por marcas. Sem elas, atualizar significaria pedir para a pessoa editar o
+ * próprio `.zshrc` à mão, e instalar duas vezes deixaria duas cópias.
+ */
+export const HOOK_BEGIN = "# >>> synthesisui align >>>";
+export const HOOK_END = "# <<< synthesisui align <<<";
+/**
+ * O bloco a escrever. `shell` decide só a forma de registrar o gancho de diretório: o zsh tem
+ * `add-zsh-hook chpwd`, o bash tem `PROMPT_COMMAND` e nenhum equivalente de `chpwd`, então lá a
+ * função se protege sozinha comparando o diretório com o da última vez.
+ */
+export function shellSnippet(shell) {
+    const body = shell === "zsh"
+        ? [
+            "sui_align() {",
+            "  [[ -d _synthesisui ]] || return",
+            '  local dir="$HOME/.cache/synthesisui" key="${PWD//\\//_}"',
+            '  mkdir -p "$dir"',
+            '  local stamp="$dir/align$key"',
+            '  if [[ -f "$stamp" ]]; then',
+            '    (( $(date +%s) - $(stat -c %Y "$stamp" 2>/dev/null || echo 0) < 3600 )) && return',
+            "  fi",
+            '  : > "$stamp"',
+            "  (npx --yes synthesisui align --shell 2>/dev/null &)",
+            "}",
+            "autoload -U add-zsh-hook",
+            "add-zsh-hook chpwd sui_align",
+            "sui_align",
+        ]
+        : [
+            "sui_align() {",
+            "  [ -d _synthesisui ] || return 0",
+            '  [ "$PWD" = "$SUI_LAST_DIR" ] && return 0',
+            '  SUI_LAST_DIR="$PWD"',
+            '  local dir="$HOME/.cache/synthesisui" key=$(echo "$PWD" | tr / _)',
+            '  mkdir -p "$dir"',
+            '  local stamp="$dir/align$key"',
+            '  if [ -f "$stamp" ]; then',
+            '    [ $(( $(date +%s) - $(stat -c %Y "$stamp" 2>/dev/null || echo 0) )) -lt 3600 ] && return 0',
+            "  fi",
+            '  : > "$stamp"',
+            "  (npx --yes synthesisui align --shell 2>/dev/null &)",
+            "}",
+            'case "$PROMPT_COMMAND" in *sui_align*) ;; *) PROMPT_COMMAND="sui_align;$PROMPT_COMMAND" ;; esac',
+        ];
+    return [
+        HOOK_BEGIN,
+        "# Tells you when this repo drifts from the design system that governs it.",
+        "# Silent when nothing is wrong. Never blocks the prompt; checks once an hour.",
+        "# Remove this block to uninstall - nothing else on disk depends on it.",
+        ...body,
+        HOOK_END,
+    ].join("\n");
+}
+/** Qual arquivo de perfil, a partir do shell que a pessoa está rodando. */
+export function rcPathFor(shell, home = homedir()) {
+    return join(home, shell === "zsh" ? ".zshrc" : ".bashrc");
+}
+/** Qual shell, lido do ambiente. `null` quando não é um dos dois - aí não há o que escrever. */
+export function shellFrom(env) {
+    const name = (env.SHELL ?? "").split("/").pop();
+    return name === "zsh" || name === "bash" ? name : null;
+}
+export function hasHook(text) {
+    return text.includes(HOOK_BEGIN);
+}
+/**
+ * O arquivo com o bloco de HOJE. Instalar de novo SUBSTITUI o bloco antigo em vez de acrescentar um
+ * segundo - senão uma melhoria no gancho viraria duas funções brigando pelo mesmo nome.
+ */
+export function withHook(text, snippet) {
+    if (!hasHook(text))
+        return `${text.replace(/\n*$/, "")}\n\n${snippet}\n`.replace(/^\n+/, "");
+    const start = text.indexOf(HOOK_BEGIN);
+    const endMark = text.indexOf(HOOK_END, start);
+    /** Marca de abertura sem a de fechamento: alguém editou à mão, e apagar até o fim seria destrutivo. */
+    if (endMark === -1)
+        return text;
+    return text.slice(0, start) + snippet + text.slice(endMark + HOOK_END.length);
+}

package/package.json

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