synthesisui 0.16.415 → 0.16.416

package/dist/agents-chosen.js

@@ -159,12 +159,11 @@ export async function chooseAgents(input) {
     const pre = remembered ?? (wired.length > 0 ? wired : await detected(input.root));
     if (!input.ask)
         return { agents: pre, from: "evidence", unknown: [] };
-    const typed = await input.ask(pre);
-    /** Enter mantém a pré-marcação - a confirmação é uma tecla, e continua sendo escolha dele. */
-    if (typed.trim() === "")
-        return { agents: pre, from: "asked", unknown: [] };
-    const read = parseAgents(typed);
-    return { agents: read.agents, from: "asked", unknown: read.unknown };
+    const picked = await input.ask(pre);
+    /** Sem terminal para perguntar, a evidência decide - o mesmo caminho de quem não tem TTY. */
+    if (picked === null)
+        return { agents: pre, from: "evidence", unknown: [] };
+    return { agents: picked, from: "asked", unknown: [] };
 }
 /**
  * A ESCOLHA REGISTRADA - e é ela que distingue "ele desmarcou" de "sobrou arquivo no disco".

package/dist/commands/connect.js

@@ -7,6 +7,7 @@ import { resolveRegistry } from "../config.js";
 import { notAProject, projectRootFrom } from "../is-a-project.js";
 import { fmt, say } from "../lang.js";
 import { body, bodyWrapped, paint, section, snippet } from "../output.js";
+import { canPick, pickMany } from "../pick-many.js";
 import { readShellAnswer, rememberShellNo } from "../shell-answer.js";
 import { existingRc, hasHook, pinnedInHook, rcPathFor, shellFrom, shellSnippet, withHook, } from "../shell-hook.js";
 import { SKILLS } from "../skills.js";
@@ -226,32 +227,29 @@ version) {
 async function askWhichAgents(pre) {
     console.log("");
     console.log(section(say("Which agents")));
-    for (const agent of AGENTS) {
-        const on = pre.includes(agent.id);
-        console.log(body(`${on ? "[x]" : "[ ]"} ${agent.label.padEnd(13)} ${on
-            ? fmt(say("{dir} is here"), { dir: agent.evidence })
-            : fmt(say("no {dir} in this repo"), { dir: agent.evidence })}`));
-    }
+    console.log(body(paint.faint(say("Space marks, arrows move, Enter confirms - nothing is written yet."))));
     console.log("");
-    console.log(body(say("Enter keeps this. To change it, type the ones you want - or `none`:")));
-    console.log(body(paint.faint(`  ${AGENTS.map((a) => a.id).join(" ")}`)));
-    const { createInterface } = await import("node:readline/promises");
-    const rl = createInterface({
-        input: process.stdin,
-        output: process.stdout,
+    if (!canPick())
+        return null;
+    const picked = await pickMany({
+        items: AGENTS.map((agent) => ({
+            id: agent.id,
+            label: agent.label,
+            note: pre.includes(agent.id)
+                ? fmt(say("{dir} is here"), { dir: agent.evidence })
+                : fmt(say("no {dir} in this repo"), { dir: agent.evidence }),
+        })),
+        picked: pre,
     });
-    const typed = await rl.question("  > ").catch(() => "");
-    rl.close();
-    return typed;
+    return picked;
 }
 /**
- * O QUE FICOU ESCOLHIDO, ecoado antes de agir - achado da revisão de DX no fecho.
+ * O QUE FICOU ESCOLHIDO, ecoado antes de agir.
  *
- * A frase da lista já diz que digitar SUBSTITUI o conjunto, e o risco não é de vocabulário: é de
- * hábito. Quem está acostumado com seletor incremental vê `[x] Codex` marcado, digita `claude`
- * querendo acrescentar, e perde o Codex. A consequência aparecia embaixo, misturada com as outras
- * linhas; uma linha só, antes de qualquer escrita, torna o engano visível no lugar onde ele
- * aconteceu.
+ * Nasceu na etapa 12 contra um engano que o seletor de agora não permite mais - lá, digitar
+ * `claude` SUBSTITUÍA a lista, e quem tinha hábito de seletor incremental perdia o outro. Com o
+ * espaço marcando, marcar é aditivo por natureza. A linha fica porque a outra metade dela continua
+ * valendo: ela é a última coisa antes das escritas, e diz o que foi para o disco.
  */
 function echoChoice(agents) {
     console.log("");

package/dist/copy/connect.pt-BR.js

@@ -43,9 +43,9 @@ register("pt-BR", {
      * razão da frase `import my design system`: onde a máquina lê, a precisão vence a gentileza.
      */
     "Which agents": "Quais agentes",
+    "Space marks, arrows move, Enter confirms - nothing is written yet.": "O espaço marca, as setas movem, o Enter confirma - nada foi escrito ainda.",
     "{dir} is here": "{dir} está aqui",
     "no {dir} in this repo": "nenhum {dir} neste repo",
-    "Enter keeps this. To change it, type the ones you want - or `none`:": "Enter mantém isto. Para mudar, digite os que você quer - ou `none`:",
     "· {label} not chosen - these stay in the repo: {files}": "· {label} não escolhido - estes ficam no repo: {files}",
     "· {label} not chosen - nothing of it was written": "· {label} não escolhido - nada dele foi escrito",
     "· Cursor is no longer wired by this CLI - what we wrote is still here: {files}": "· o Cursor não é mais fiado por este CLI - o que a gente escreveu continua aqui: {files}",

package/dist/install-marks.js

@@ -214,7 +214,19 @@
  * O que o cliente ganha ao rodar `upgrade`: nada de uma ferramenta que ele não usa é reescrito no
  * repositório dele.
  */
-export const MATERIALISER_SINCE = "0.16.415";
+/**
+ * 0.16.415 -> 0.16.416 em 10/09: a lista de agentes passa a ser MARCADA com o espaço, e não
+ * digitada. Ele testou a versão anterior no próprio repositório e disse: *"eu não consigo
+ * selecionar, eu queria clicar ou selecionar com o espaço para checar"* - a tela desenhava `[x]` e
+ * `[ ]`, a forma universal de caixa de seleção, e exigia digitar o nome do agente.
+ *
+ * A marca sobe porque a ESCOLHA decide o conjunto de arquivos que cai na pasta dele, e um
+ * `connect` pinado numa versão anterior pede aquela escolha de um jeito que ele já tentou e que
+ * não funcionou.
+ *
+ * O que o cliente ganha ao rodar `upgrade`: a lista responde ao espaço, como a caixa promete.
+ */
+export const MATERIALISER_SINCE = "0.16.416";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *

package/dist/pick-many.js

@@ -0,0 +1,108 @@
+/**
+ * ELE MARCA COM O ESPAÇO - a lista de escolha MÚLTIPLA do terminal.
+ *
+ * O DEFEITO QUE ISTO CONSERTA, e ele foi achado por ELE testando a entrega anterior no próprio
+ * repositório (10/09): *"eu não consigo selecionar, eu queria clicar ou selecionar com o espaço
+ * para checar"*. A lista desenhava `[x]` e `[ ]` - a forma universal de caixa de seleção - e
+ * exigia digitar o nome do item. A tela prometia uma interação que não existia, e a promessa da
+ * tela é a única que a pessoa lê.
+ *
+ * O IRMÃO JÁ EXISTIA: `commands/import.ts` tem um seletor de escolha ÚNICA desde 31/07 - setas,
+ * Enter, Ctrl-C tratado, redesenho subindo N linhas. Este é o mesmo mecanismo com a diferença que
+ * importa: o espaço marca e desmarca, e a resposta é uma lista. Os dois ficam, porque a pergunta
+ * "qual" e a pergunta "quais" são diferentes na tela; o que não pode existir é uma TERCEIRA
+ * leitura de tecla neste CLI.
+ *
+ * ─────────────────────────────────────────────────────────────────────────
+ * AS TRÊS COISAS QUE PODEM DAR ERRADO FORA DO NOSSO PROGRAMA, e é por elas que este módulo é
+ * pequeno e fechado:
+ *
+ *     o raw mode fica ligado     o shell dele para de ecoar o que ele digita, muito depois de a
+ *                               gente ter terminado. Restaurado em TODA saída, inclusive a de erro
+ *     Ctrl-C vira escolha       sair não é escolher. O `onQuit` encerra sem resolver a promessa
+ *     não há terminal           não se tenta ler tecla nenhuma: quem chama decide o que fazer,
+ *                               e no `connect` isso já tem resposta desde a etapa 12
+ *
+ * `stdin` e `stdout` são ARGUMENTOS porque um seletor que fala com `process` direto não tem como
+ * ser provado sem um terminal - e o que precisa de prova aqui é a leitura de tecla, não o
+ * desenho.
+ */
+/** O terminal tem teclado? Sem isto, não se tenta ler tecla nenhuma. */
+export const canPick = (stdin = process.stdin, stdout = process.stdout) => Boolean(stdin.isTTY) &&
+    Boolean(stdout.isTTY) &&
+    typeof stdin.setRawMode === "function";
+const UP = "";
+const DOWN = "";
+const ENTER_KEYS = ["\r", "\n"];
+const CTRL_C = "";
+export function pickMany(input) {
+    const stdin = (input.stdin ?? process.stdin);
+    const stdout = input.stdout ?? process.stdout;
+    const items = input.items;
+    const marked = new Set(input.picked);
+    let at = 0;
+    let first = true;
+    const render = () => {
+        if (!first)
+            stdout.write(`[${items.length}A`);
+        first = false;
+        for (const [i, item] of items.entries()) {
+            const box = marked.has(item.id) ? "[x]" : "[ ]";
+            const cursor = i === at ? ">" : " ";
+            const note = item.note ? `  ${item.note}` : "";
+            stdout.write(`  ${cursor} ${box} ${item.label.padEnd(13)}${note}\n`);
+        }
+    };
+    render();
+    return new Promise((resolve) => {
+        /**
+         * UMA SAÍDA SÓ, e é ela que garante a promessa do raw mode. Toda tecla que termina a
+         * pergunta passa por aqui - inclusive o Ctrl-C.
+         */
+        const leave = () => {
+            stdin.off("data", onData);
+            if (stdin.isTTY)
+                stdin.setRawMode?.(false);
+            stdin.pause();
+        };
+        const onData = (buf) => {
+            const key = buf.toString();
+            if (key === CTRL_C) {
+                leave();
+                stdout.write("\n");
+                (input.onQuit ?? (() => process.exit(130)))();
+                return;
+            }
+            if (key === UP || key === "k") {
+                at = (at + items.length - 1) % items.length;
+                render();
+                return;
+            }
+            if (key === DOWN || key === "j" || key === "\t") {
+                at = (at + 1) % items.length;
+                render();
+                return;
+            }
+            if (key === " ") {
+                const id = items[at]?.id;
+                if (id !== undefined) {
+                    if (marked.has(id))
+                        marked.delete(id);
+                    else
+                        marked.add(id);
+                    render();
+                }
+                return;
+            }
+            if (ENTER_KEYS.includes(key)) {
+                leave();
+                /** Na ORDEM da lista, e não na ordem em que ele marcou - a tela é que ele leu. */
+                resolve(items.filter((i) => marked.has(i.id)).map((i) => i.id));
+            }
+        };
+        if (stdin.isTTY)
+            stdin.setRawMode?.(true);
+        stdin.resume();
+        stdin.on("data", onData);
+    });
+}

package/package.json

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