synthesisui 0.16.425 → 0.16.427

package/dist/commands/autopilot.js

@@ -0,0 +1,167 @@
+import { resolve } from "node:path";
+import { readToken, resolveRegistry } from "../config.js";
+import { installedSlugs } from "../installed.js";
+import { body, paint, section } from "../output.js";
+const isState = (x) => !!x &&
+    typeof x === "object" &&
+    typeof x.on === "boolean" &&
+    typeof x.landsOn === "string";
+/**
+ * O ESTADO, EM UMA LINHA - e o nome do sistema junto, porque um repo pode ter dois.
+ *
+ * O SLUG É O LOCAL, NUNCA O QUE VOLTOU DA REDE - achado da revisão de QA no fecho. Ele é a
+ * PERGUNTA, não a resposta: num repo com dois sistemas instalados, uma resposta que trouxesse
+ * outro nome faria o terminal dizer que mudou o sistema em que ela não mexeu. A lei de imprimir o
+ * lido de volta vale para o ESTADO, que é o que a rota decide.
+ */
+const stateLine = (s, slug) => `Autopilot is ${s.on ? "on" : "off"} for you in ${slug}.`;
+/**
+ * POR QUE ELE ESTÁ ASSIM - e as três respostas são coisas diferentes.
+ *
+ * `unavailable` é a lacuna declarada: dizer "alguém te desligou" sobre uma tabela que aquele banco
+ * ainda não tem é falso duas vezes - ninguém desligou, e o que houve foi uma leitura que não
+ * respondeu. Lacuna calada é bug (lei 8).
+ */
+const whyLine = (s) => s.why === "chosen"
+    ? `you switched this ${s.on ? "on" : "off"} yourself, and it stands even if the system default changes.`
+    : s.why === "default"
+        ? "you have no choice of your own here, so the system default answers for you."
+        : "per-person Autopilot has not reached this system yet, so nobody switched you off - off is the honest answer until it does.";
+/** Onde o trabalho dela cai - a segunda pergunta de quem acabou de mudar a automação. */
+const landsLine = (s, base, slug) => s.landsOn === "branch"
+    ? `your work lands in YOUR branch, not on the main line your team installs - it reaches them when whoever owns this system approves it: ${base}/dashboard/mine/${slug}`
+    : "your work goes straight to the main line your team installs.";
+function say(s, base, slug) {
+    console.log(section("Autopilot"));
+    console.log(body(paint.strong(stateLine(s, slug))));
+    console.log(body(paint.dim(whyLine(s))));
+    console.log(body(paint.dim(landsLine(s, base, slug))));
+    console.log("");
+}
+export async function autopilot(opts) {
+    const root = resolve(opts.dir ?? process.cwd());
+    const base = resolveRegistry(opts.registry);
+    const asked = opts.wanted?.trim().toLowerCase();
+    /**
+     * A PALAVRA É CONFERIDA ANTES DE QUALQUER IDA À REDE - e antes do login, inclusive. Mandar
+     * `maybe` para o servidor e deixá-lo recusar gastaria uma volta para dizer o que já se sabe
+     * aqui, e devolveria a ela uma frase sobre a rota em vez das duas escolhas que existem.
+     */
+    if (asked && asked !== "on" && asked !== "off") {
+        console.log(section("Autopilot"));
+        console.log(body(`"${opts.wanted}" is not a choice here. The two are: ${paint.strong("on")} and ${paint.strong("off")}.`));
+        console.log(body(paint.faint("    synthesisui autopilot        # what it is right now, without changing it")));
+        /**
+         * E ELE SAI COM FALHA - achado da revisão de QA no fecho: um script que roda
+         * `synthesisui autopilot $CHOICE` com a variável vazia ou com um valor digitado errado
+         * seguiria como se tivesse mudado. É a mesma lei do 403, e o caminho mais provável de chegar
+         * aqui é justamente automação, não uma pessoa digitando.
+         */
+        process.exitCode = 1;
+        return;
+    }
+    const token = await readToken(opts.home);
+    if (!token) {
+        console.log(section("Autopilot"));
+        console.log(body("Not logged in, so there is nothing to read here - this switch is yours on the platform, not a file in this clone:"));
+        console.log(body(paint.blue("    synthesisui login")));
+        return;
+    }
+    /**
+     * QUAL SISTEMA - o `.lock` é o que diz qual slug este repositório alimenta.
+     *
+     * Num repo com dois, ele age no primeiro em ordem alfabética, e a saída NOMEIA qual: um comando
+     * que age calado sobre "o primeiro" é um comando que ela não tem como conferir.
+     */
+    const installed = await installedSlugs(root);
+    const slug = installed[0];
+    if (!slug) {
+        console.log(section("Autopilot"));
+        console.log(body("No installed system here, so there is no Autopilot to read. Install the one this repo follows first:"));
+        console.log(body(paint.blue("    npx synthesisui@latest add <slug>")));
+        console.log(body(paint.faint("    npx synthesisui@latest list --mine    # the slugs you own")));
+        return;
+    }
+    const url = `${base}/api/registry/ds/${slug}/autopilot`;
+    const auth = { authorization: `Bearer ${token}` };
+    /** A leitura, e ela é a mesma nos dois caminhos - perguntar, e dizer o que continua valendo. */
+    const read = async () => {
+        const res = await fetch(url, { headers: auth });
+        if (!res.ok)
+            return null;
+        const data = (await res.json().catch(() => null));
+        return isState(data) ? data : null;
+    };
+    const unreachable = (why) => {
+        console.log(section("Autopilot"));
+        console.log(body(`This machine could not reach the platform, so nothing was read and nothing was changed: ${base}${why instanceof Error ? ` (${why.message})` : ""}. Try again when you are back online, or point it at the right place with --registry <url>.`));
+        process.exitCode = 1;
+    };
+    if (!asked) {
+        try {
+            const now = await read();
+            if (!now) {
+                console.log(section("Autopilot"));
+                console.log(body(`${paint.strong(slug)} did not answer for this account at ${base}. If your session is old, log in again: ${paint.blue("synthesisui login")}`));
+                process.exitCode = 1;
+                return;
+            }
+            say(now, base, slug);
+        }
+        catch (error) {
+            unreachable(error);
+        }
+        return;
+    }
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { ...auth, "content-type": "application/json" },
+            body: JSON.stringify({ choice: asked }),
+        });
+        if (res.status === 403) {
+            /**
+             * A RECUSA VEM DO SERVIDOR, INTEIRA - ela nomeia o papel que resolve, e é isso que separa
+             * "não deu" de "fale com quem administra as pessoas deste grupo".
+             */
+            const said = (await res.json().catch(() => null));
+            console.log(section("Autopilot"));
+            console.log(body(said?.error ??
+                "That is not yours to change here, and the server did not say who it belongs to."));
+            process.exitCode = 1;
+            /** E O QUE CONTINUA VALENDO, porque uma recusa sem o estado deixa ela sem saber onde está. */
+            const now = await read().catch(() => null);
+            if (now)
+                say(now, base, slug);
+            return;
+        }
+        if (res.status === 404) {
+            console.log(section("Autopilot"));
+            console.log(body(`${paint.strong(slug)} does not reach this account at ${base}, so there is nothing to change here. If your session is old, log in again: ${paint.blue("synthesisui login")}`));
+            process.exitCode = 1;
+            return;
+        }
+        if (!res.ok) {
+            console.log(section("Autopilot"));
+            console.log(body(`${base} answered ${res.status} to that, so nothing was changed. Nothing of yours was lost.`));
+            process.exitCode = 1;
+            return;
+        }
+        /**
+         * O ESTADO IMPRESSO É O QUE A ROTA RELEU DO BANCO depois de escrever - nunca o que este
+         * processo pediu. Ver o cabeçalho: um interruptor que parece ligado e não está é pior que um
+         * que recusa.
+         */
+        const now = (await res.json().catch(() => null));
+        if (!isState(now)) {
+            console.log(section("Autopilot"));
+            console.log(body(`${base} answered something this version cannot read, so it is not saying what the switch is now. Upgrade and try again: npx synthesisui@latest autopilot`));
+            process.exitCode = 1;
+            return;
+        }
+        say(now, base, slug);
+    }
+    catch (error) {
+        unreachable(error);
+    }
+}

package/dist/commands/import.js

@@ -490,7 +490,13 @@ export async function takeCensus(root, opts) {
      * `textarea` (dono, 01/08). Fetched rather than shipped, and the fallback is announced
      * with what it costs - a smaller answer is fine, a silently smaller one is not.
      */
-    const fetched = await fetchCatalogue(opts?.registry);
+    const fetched = opts?.offline
+        ? {
+            ok: false,
+            why: "offline",
+            because: "this run makes no network calls by contract",
+        }
+        : await fetchCatalogue(opts?.registry);
     useLiveCatalogue(fetched.ok ? asCatalogueTable(fetched.index) : null);
     /** Todo arquivo de estilo do escopo, para o ledger - ver o parâmetro `into`. */
     const styleFiles = [];
@@ -4315,7 +4321,16 @@ export async function runImport(opts) {
          * every file opened, every candidate ruled out - is the machine talking to
          * itself (dono, 01/08).
          */
-        phase(1, 3, "Measuring the repository");
+        /**
+         * "1/3" É UMA PROMESSA DE TRÊS PASSOS, e o `inspect` tem UM.
+         *
+         * O contador existe para quem está importando: ele diz em qual das três fases a pessoa está
+         * e que ainda faltam duas. Quem rodou `inspect` não vai mandar nada e não vai resolver
+         * leitura nenhuma - abrir o primeiro contato do produto anunciando dois passos que não vêm é
+         * prometer trabalho que ninguém pediu.
+         */
+        if (!opts.inspect)
+            phase(1, 3, "Measuring the repository");
         console.log(section("Reading your project"));
         /**
          * UMA MEDIÇÃO POR ESCOPO, E DEPOIS A FUSÃO.
@@ -4338,6 +4353,8 @@ export async function runImport(opts) {
                 ...(i === 0 && usage.length > 0 ? { usage } : {}),
                 ...(one ? { scopeLabel: one } : {}),
                 ...(opts.cli ? { cli: opts.cli } : {}),
+                /** `inspect` não fala com ninguém - ver `offline` em `takeCensus`. */
+                ...(opts.inspect ? { offline: true } : {}),
             });
             if (one)
                 c.scope = one;
@@ -4359,6 +4376,23 @@ export async function runImport(opts) {
      */
     if (!opts.census)
         await resolveReadParts(census, root);
+    /**
+     * O QUE ELE ESCREVEU VEM ANTES DO QUE ELE REPETIU - e a ordem era a inversa.
+     *
+     * `summarize` abre com "13 distinct design values · 17 colour · 10 spacing", e os componentes
+     * com as variantes que este leitor extraiu do código dele vinham no fim, atrás de tudo. Quem lê
+     * um terminal lê de cima para baixo e conclui pela primeira seção: a leitura profunda era
+     * apresentada como se fosse um contador de pixels repetidos.
+     *
+     * `Button variant(primary|ghost) size(lg)` é a coisa mais difícil que esta esteira faz, e é a
+     * que diz que o vocabulário do frontend dele foi entendido. Ela abre.
+     *
+     * E ABRE NOS DOIS COMANDOS. Duas ordens para a mesma leitura é a mesma doença de duas verdades:
+     * o `import` não ganha nada sendo a versão pior de si mesmo, e quem roda os dois na mesma
+     * semana teria que aprender duas telas (dono, 13/09 - a decisão de ordem é do terminal, não do
+     * produto, e portanto minha).
+     */
+    printComponents(census);
     await summarize(census, root, scope);
     /**
      * ONDE ESTOU vem antes de O QUE EU LEIO, e o `!scope` calava exatamente quem
@@ -4402,6 +4436,27 @@ export async function runImport(opts) {
     // there - config, `ds/<slug>/`, the hook's marker - and the census was the
     // only artefact that travelled with `--dir`, which is how two of them ended
     // up disagreeing about which import happened (dono, 31/07).
+    /**
+     * A FRONTEIRA DO `inspect`, e ela é uma linha só porque a leitura já terminou.
+     *
+     * Tudo acima imprimiu; a primeira escrita é a próxima instrução. Retornar aqui entrega os
+     * quatro contratos de uma vez, sem um caminho paralelo que possa divergir.
+     *
+     * O QUE ELE VÊ NO LUGAR DO ARQUIVO: a frase que diz o que sobra a fazer - e ela NÃO faz.
+     * Um comando de primeiro contato que termina executando o passo seguinte é o comando que a
+     * pessoa não vai rodar de novo.
+     */
+    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("");
+        return;
+    }
     const out = opts.census ?? join(root, "_synthesisui", "census.json");
     await mkdir(dirname(out), { recursive: true });
     await writeFile(out, `${JSON.stringify(census, null, 2)}\n`, "utf8");
@@ -4427,7 +4482,8 @@ export async function runImport(opts) {
     if (opts.dry) {
         console.log(body("Nothing was sent. Read the file, then run it without --dry."));
         sayReach(census);
-        printComponents(census);
+        /* `printComponents` subiu para antes de `summarize` e vale para todo caminho - repetir
+           aqui imprimiria os componentes duas vezes na mesma execução. */
         printAgentContract();
         console.log("");
         return;

package/dist/doctor/catalogue-fetch.js

@@ -84,5 +84,21 @@ export function asCatalogueTable(index) {
  * "using the built-in list" is not.
  */
 export function describeFallback(result, floorSize) {
-    return `${result.because}. Matching used the ${floorSize} names built into this CLI instead of the live catalogue, so a component of yours that lines up with something we added recently will read as exclusively yours. That is a smaller answer, not a wrong one - re-run with a session to get the full one.`;
+    /**
+     * "RE-RUN WITH A SESSION" É UM CONSELHO ERRADO PARA QUEM JÁ TEM UMA - e `offline` é
+     * exatamente esse caso.
+     *
+     * Os outros dois motivos são falhas de acesso: sem sessão, ou recusada. Entrar resolve, e a
+     * frase manda entrar. `offline` é uma ESCOLHA do comando - `inspect` não fala com ninguém por
+     * contrato -, então a mesma frase virava uma contradição na tela: o terminal dizia "esta
+     * execução não faz chamada de rede" e, na oração seguinte, "rode de novo com uma sessão"
+     * para alguém que estava logada o tempo todo (medido em 13/09, rodando na máquina do dono).
+     *
+     * Dizer a verdade aqui custa uma condição, e a alternativa é ensinar a pessoa a desconfiar
+     * das outras frases do mesmo relatório.
+     */
+    const saida = result.why === "offline"
+        ? "`synthesisui import` matches against the full list"
+        : "re-run with a session to get the full one";
+    return `${result.because}. Matching used the ${floorSize} names built into this CLI instead of the live catalogue, so a component of yours that lines up with something we added recently will read as exclusively yours. That is a smaller answer, not a wrong one - ${saida}.`;
 }

package/dist/index.js

@@ -8,6 +8,7 @@ import { add } from "./commands/add.js";
 import { adopt } from "./commands/adopt.js";
 import { advise } from "./commands/advise.js";
 import { align } from "./commands/align.js";
+import { autopilot } from "./commands/autopilot.js";
 import { ci } from "./commands/ci.js";
 import { clean } from "./commands/clean.js";
 import { component } from "./commands/component.js";
@@ -60,6 +61,10 @@ Usage - deterministic, FREE:
   synthesisui clean [--force]              strip create-next-app boilerplate (dry run without --force)
 
 Usage - governance (deterministic, FREE):
+  synthesisui inspect [--scope <p>]        read this repository and say what it sees: your components,
+                                           their variant axes and options, their parts and shape, and
+                                           where one is built from another - then the values you repeat,
+                                           with file and line. No account, no network, nothing written
   synthesisui adopt [--write]              turn the design system you ALREADY have into a contract
   synthesisui import [--scope <p>] [--usage <p>]  read what you already have and make it a system
                                            your agent follows - without touching your CSS
@@ -88,6 +93,11 @@ Usage - governance (deterministic, FREE):
                                            declare, and says what it offers instead. create: it
                                            reports and gets out of the way. No argument answers
                                            where you are. Local to this clone, never committed
+  synthesisui autopilot [on|off]           the Autopilot, FOR YOU in this system: on applies what it
+                                           finds on your work without asking, off stops it acting
+                                           for you - your sync still goes up either way. No argument
+                                           answers where you are, and it always says which line your
+                                           work is landing in
   synthesisui hook                         the check itself; installed by connect, run by your editor
   synthesisui mcp                          the system as tools; installed by connect, run by your agent
 
@@ -251,6 +261,45 @@ async function main() {
                 registry,
             });
             break;
+        /**
+         * `inspect` - LEIA O MEU CÓDIGO E ME DIGA O QUE VOCÊ VÊ.
+         *
+         * O QUE O CLIENTE GANHA: em segundos, sem criar conta e sem que nada seja escrito no
+         * repositório dele, ele vê o vocabulário do próprio frontend lido de volta - os componentes,
+         * os eixos de variante com as opções, as partes, a forma como elas se aninham no código dele,
+         * e onde um componente dele é feito de outro. Depois os valores que ele repete, com arquivo e
+         * linha. E o que este leitor NÃO entendeu, também com arquivo e linha.
+         *
+         * POR QUE ELE EXISTE, SE `import --dry` já fazia isso: fazia, e com o nome errado para o
+         * momento errado. Para quem nunca ouviu falar da plataforma, `import` promete escrita e
+         * `--dry` é jargão nosso - e, pior, aquele caminho REALMENTE escrevia três arquivos
+         * (`census.json`, `not-expressed.md` e o `ledger.jsonl` que nasce junto com a pasta). A
+         * pergunta que ele provocava era *"posso confiar neste comando?"*, quando a única pergunta
+         * que deveria estar na cabeça de quem roda é *"como é que ele entendeu o meu Button?"*.
+         *
+         * ELE NÃO SUBSTITUI O `doctor`, e os dois não se fundem: `inspect` responde "o que você vê?",
+         * `doctor` responde "onde isto está derivando?". São perguntas de momentos diferentes, e um
+         * comando que responde as duas responde mal as duas.
+         */
+        case "inspect":
+            await runImport({
+                root: dir,
+                cli: CLI_VERSION,
+                inspect: true,
+                scope: Array.isArray(flags.scope)
+                    ? flags.scope
+                    : typeof flags.scope === "string"
+                        ? flags.scope
+                        : undefined,
+                usage: [flags.usage]
+                    .flat()
+                    .filter((v) => typeof v === "string")
+                    .flatMap((v) => v.split(","))
+                    .map((v) => v.trim())
+                    .filter(Boolean),
+                registry,
+            });
+            break;
         case "adopt":
             // Dry by default: `--write` is the only way anything lands on disk.
             await adopt({
@@ -286,6 +335,20 @@ async function main() {
         case "mode":
             await mode({ dir, ...(args[0] ? { wanted: args[0] } : {}) });
             break;
+        /**
+         * O INTERRUPTOR DELA NA PLATAFORMA - ver `autopilot.ts`.
+         *
+         * O irmão de `mode`, e a diferença importa: `mode` é local a este clone, e este muda um estado
+         * que mora no servidor e que a tela de configurações mexe pela outra porta. Sem argumento ele
+         * RESPONDE, pela mesma razão dos dois.
+         */
+        case "autopilot":
+            await autopilot({
+                dir,
+                registry,
+                ...(args[0] ? { wanted: args[0] } : {}),
+            });
+            break;
         // Long-lived: it owns stdin/stdout until the client closes the pipe, so
         // it must not be reached by anything that prints.
         case "mcp":

package/package.json

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